33 #ifndef INCLUDE_EXPRTK_HPP
34 #define INCLUDE_EXPRTK_HPP
61 #ifdef exprtk_enable_debugging
62 #define exprtk_debug(params) printf params
64 #define exprtk_debug(params) (void)0
67 #define exprtk_error_location \
68 "exprtk.hpp:" + details::to_str(__LINE__) \
70 #if defined(__GNUC__) && (__GNUC__ >= 7)
72 #define exprtk_disable_fallthrough_begin \
73 _Pragma ("GCC diagnostic push") \
74 _Pragma ("GCC diagnostic ignored \"-Wimplicit-fallthrough\"") \
76 #define exprtk_disable_fallthrough_end \
77 _Pragma ("GCC diagnostic pop") \
80 #define exprtk_disable_fallthrough_begin (void)0;
81 #define exprtk_disable_fallthrough_end (void)0;
95 return (
' ' == c) || (
'\n' == c) ||
96 (
'\r' == c) || (
'\t' == c) ||
97 (
'\b' == c) || (
'\v' == c) ||
103 return (
'+' == c) || (
'-' == c) ||
104 (
'*' == c) || (
'/' == c) ||
105 (
'^' == c) || (
'<' == c) ||
106 (
'>' == c) || (
'=' == c) ||
107 (
',' == c) || (
'!' == c) ||
108 (
'(' == c) || (
')' == c) ||
109 (
'[' == c) || (
']' == c) ||
110 (
'{' == c) || (
'}' == c) ||
111 (
'%' == c) || (
':' == c) ||
112 (
'?' == c) || (
'&' == c) ||
113 (
'|' == c) || (
';' == c) ;
118 return ((
'a' <= c) && (c <=
'z')) ||
119 ((
'A' <= c) && (c <=
'Z')) ;
124 return (
'0' <= c) && (c <=
'9');
134 return (
'(' == c) || (
'[' == c) || (
'{' == c);
139 return (
')' == c) || (
']' == c) || (
'}' == c);
149 return (
'+' == c) || (
'-' == c);
165 #ifndef exprtk_disable_caseinsensitivity
168 for (std::size_t i = 0; i < s.size(); ++i)
170 s[i] =
static_cast<std::string::value_type
>(std::tolower(s[i]));
176 return std::tolower(c1) == std::tolower(c2);
179 inline bool imatch(
const std::string& s1,
const std::string& s2)
181 if (s1.size() == s2.size())
183 for (std::size_t i = 0; i < s1.size(); ++i)
185 if (std::tolower(s1[i]) != std::tolower(s2[i]))
199 inline bool operator() (
const std::string& s1,
const std::string& s2)
const
201 const std::size_t length =
std::min(s1.size(),s2.size());
203 for (std::size_t i = 0; i < length; ++i)
205 const char_t c1 =
static_cast<char>(std::tolower(s1[i]));
206 const char_t c2 =
static_cast<char>(std::tolower(s2[i]));
214 return s1.size() < s2.size();
227 inline bool imatch(
const std::string& s1,
const std::string& s2)
234 inline bool operator() (
const std::string& s1,
const std::string& s2)
const
244 return (4 == symbol.size()) &&
245 (
'$' == symbol[0]) &&
258 return s[s.size() - 1];
264 return std::string(
"0");
272 result +=
'0' + char(-(i % 10));
281 result +=
'0' + char(i % 10);
285 std::reverse(result.begin(), result.end());
292 return to_str(static_cast<int>(i));
297 return ((
'0' <= digit) && (digit <=
'9')) ||
298 ((
'A' <= digit) && (digit <=
'F')) ||
299 ((
'a' <= digit) && (digit <=
'f')) ;
304 if ((
'0' <= h) && (h <=
'9'))
307 return static_cast<unsigned char>(std::toupper(h) -
'A');
310 template <
typename Iterator>
311 inline void parse_hex(Iterator& itr, Iterator end, std::string::value_type& result)
315 (end != (itr + 1)) &&
316 (end != (itr + 2)) &&
317 (end != (itr + 3)) &&
320 (
'x' == *(itr + 1)) ||
327 result =
hex_to_bin(static_cast<uchar_t>(*(itr + 2))) << 4 |
328 hex_to_bin(static_cast<uchar_t>(*(itr + 3))) ;
337 typedef std::string::iterator str_itr_t;
339 str_itr_t itr1 = s.begin();
340 str_itr_t itr2 = s.begin();
341 str_itr_t end = s.end ();
343 std::size_t removal_count = 0;
353 else if (
'\\' != (*itr1))
357 case 'n' : (*itr1) =
'\n';
break;
358 case 'r' : (*itr1) =
'\r';
break;
359 case 't' : (*itr1) =
'\t';
break;
360 case '0' :
parse_hex(itr1, end, (*itr1));
378 s.resize(s.size() - removal_count);
387 data_.reserve(initial_size);
398 data_ += std::string(s);
402 inline operator std::string ()
const
419 "break",
"case",
"continue",
"default",
"false",
"for",
420 "if",
"else",
"ilike",
"in",
"like",
"and",
"nand",
"nor",
421 "not",
"null",
"or",
"repeat",
"return",
"shl",
"shr",
422 "swap",
"switch",
"true",
"until",
"var",
"while",
"xnor",
430 "abs",
"acos",
"acosh",
"and",
"asin",
"asinh",
"atan",
431 "atanh",
"atan2",
"avg",
"break",
"case",
"ceil",
"clamp",
432 "continue",
"cos",
"cosh",
"cot",
"csc",
"default",
433 "deg2grad",
"deg2rad",
"equal",
"erf",
"erfc",
"exp",
434 "expm1",
"false",
"floor",
"for",
"frac",
"grad2deg",
435 "hypot",
"iclamp",
"if",
"else",
"ilike",
"in",
"inrange",
436 "like",
"log",
"log10",
"log2",
"logn",
"log1p",
"mand",
437 "max",
"min",
"mod",
"mor",
"mul",
"ncdf",
"nand",
"nor",
438 "not",
"not_equal",
"null",
"or",
"pow",
"rad2deg",
439 "repeat",
"return",
"root",
"round",
"roundn",
"sec",
"sgn",
440 "shl",
"shr",
"sin",
"sinc",
"sinh",
"sqrt",
"sum",
"swap",
441 "switch",
"tan",
"tanh",
"true",
"trunc",
"until",
"var",
442 "while",
"xnor",
"xor",
"&",
"|"
449 "abs",
"acos",
"acosh",
"asin",
"asinh",
"atan",
"atanh",
450 "atan2",
"avg",
"ceil",
"clamp",
"cos",
"cosh",
"cot",
451 "csc",
"equal",
"erf",
"erfc",
"exp",
"expm1",
"floor",
452 "frac",
"hypot",
"iclamp",
"like",
"log",
"log10",
"log2",
453 "logn",
"log1p",
"mand",
"max",
"min",
"mod",
"mor",
"mul",
454 "ncdf",
"pow",
"root",
"round",
"roundn",
"sec",
"sgn",
455 "sin",
"sinc",
"sinh",
"sqrt",
"sum",
"swap",
"tan",
"tanh",
456 "trunc",
"not_equal",
"inrange",
"deg2grad",
"deg2rad",
457 "rad2deg",
"grad2deg"
464 "and",
"nand",
"nor",
"not",
"or",
"xnor",
"xor",
"&",
"|"
471 "if",
"switch",
"for",
"while",
"repeat",
"return"
478 "+",
"-",
"*",
"/",
"%",
"^"
577 return (std::tolower(c0) == std::tolower(c1));
581 template <
typename Iterator,
typename Compare>
583 const Iterator pattern_end,
584 const Iterator data_begin,
585 const Iterator data_end,
586 const typename std::iterator_traits<Iterator>::value_type& zero_or_more,
587 const typename std::iterator_traits<Iterator>::value_type& zero_or_one)
589 Iterator d_itr = data_begin;
590 Iterator p_itr = pattern_begin;
592 while ((p_itr != pattern_end) && (d_itr != data_end))
594 if (zero_or_more == *p_itr)
596 while ((p_itr != pattern_end) && (*p_itr == zero_or_more || *p_itr == zero_or_one))
601 if (p_itr == pattern_end)
604 const typename std::iterator_traits<Iterator>::value_type c = *(p_itr++);
606 while ((d_itr != data_end) && !Compare::cmp(c,*d_itr))
613 else if ((*p_itr == zero_or_one) || Compare::cmp(*p_itr, *d_itr))
622 if (d_itr != data_end)
624 else if (p_itr == pattern_end)
626 else if ((zero_or_more == *p_itr) || (zero_or_one == *p_itr))
629 return pattern_end == p_itr;
633 const std::string& str)
635 return match_impl<char_cptr,cs_match>(wild_card.data(),
636 wild_card.data() + wild_card.size(),
638 str.data() + str.size(),
644 const std::string& str)
646 return match_impl<char_cptr,cis_match>(wild_card.data(),
647 wild_card.data() + wild_card.size(),
649 str.data() + str.size(),
655 const std::string& str,
656 std::size_t& diff_index,
661 return (
"Z" == pattern);
663 else if (
'*' == pattern[0])
666 typedef std::string::const_iterator itr_t;
668 itr_t p_itr = pattern.begin();
669 itr_t s_itr = str .begin();
671 itr_t p_end = pattern.end();
672 itr_t s_end = str .end();
674 while ((s_end != s_itr) && (p_end != p_itr))
678 const char_t target =
static_cast<char>(std::toupper(*(p_itr - 1)));
682 diff_index =
static_cast<std::size_t
>(std::distance(str.begin(),s_itr));
683 diff_value =
static_cast<char>(std::toupper(*p_itr));
690 while (s_itr != s_end)
692 if (target != std::toupper(*s_itr))
702 std::toupper(*p_itr) != std::toupper(*s_itr)
705 diff_index =
static_cast<std::size_t
>(std::distance(str.begin(),s_itr));
706 diff_value =
static_cast<char>(std::toupper(*p_itr));
726 1.0E+001, 1.0E+002, 1.0E+003, 1.0E+004,
727 1.0E+005, 1.0E+006, 1.0E+007, 1.0E+008,
728 1.0E+009, 1.0E+010, 1.0E+011, 1.0E+012,
729 1.0E+013, 1.0E+014, 1.0E+015, 1.0E+016
738 static const double e = 2.71828182845904523536028747135266249775724709369996;
739 static const double pi = 3.14159265358979323846264338327950288419716939937510;
740 static const double pi_2 = 1.57079632679489661923132169163975144209858469968755;
741 static const double pi_4 = 0.78539816339744830961566084581987572104929234984378;
742 static const double pi_180 = 0.01745329251994329576923690768488612713442871888542;
743 static const double _1_pi = 0.31830988618379067153776752674502872406891929148091;
744 static const double _2_pi = 0.63661977236758134307553505349005744813783858296183;
745 static const double _180_pi = 57.29577951308232087679815481410517033240547246656443;
746 static const double log2 = 0.69314718055994530941723212145817656807550013436026;
747 static const double sqrt2 = 1.41421356237309504880168872420969807856967187537695;
757 template <
typename T>
764 #define exprtk_register_real_type_tag(T) \
765 template<> struct number_type<T> \
766 { typedef real_type_tag type; number_type() {} }; \
768 #define exprtk_register_complex_type_tag(T) \
769 template<> struct number_type<std::complex<T> > \
770 { typedef complex_type_tag type; number_type() {} }; \
772 #define exprtk_register_int_type_tag(T) \
773 template<> struct number_type<T> \
774 { typedef int_type_tag type; number_type() {} }; \
791 #undef exprtk_register_real_type_tag
792 #undef exprtk_register_int_type_tag
794 template <
typename T>
797 static inline T
value()
799 const T epsilon = T(0.0000000001);
805 struct epsilon_type <float>
809 const float epsilon = float(0.000001f);
815 struct epsilon_type <long double>
819 const long double epsilon = (
long double)(0.000000000001);
824 template <
typename T>
827 return std::not_equal_to<T>()(v,v);
830 template <
typename T>
833 return static_cast<int>(
v);
836 template <
typename T>
839 return static_cast<long long int>(
v);
842 template <
typename T>
845 return std::not_equal_to<T>()(T(0),
v);
848 template <
typename T>
851 return std::equal_to<T>()(T(0),
v);
854 template <
typename T>
857 return ((v < T(0)) ? -v : v);
860 template <
typename T>
863 return std::min<T>(v0,v1);
866 template <
typename T>
869 return std::max<T>(v0,v1);
872 template <
typename T>
885 template <
typename T>
888 return (v0 == v1) ? 1 : 0;
891 template <
typename T>
896 return v + (T(0.5) * v *
v);
898 return std::exp(v) - T(1);
901 template <
typename T>
904 return T(std::exp<double>(v)) - T(1);
907 template <
typename T>
922 template <
typename T>
925 return (v0 != v1) ? 1 : 0;
928 template <
typename T>
931 return std::fmod(v0,v1);
934 template <
typename T>
940 template <
typename T>
946 template <
typename T>
949 return std::pow(static_cast<double>(v0),static_cast<double>(v1));
952 template <
typename T>
955 return std::log(v0) / std::log(v1);
958 template <
typename T>
961 return static_cast<T
>(logn_impl<double>(
static_cast<double>(v0),static_cast<double>(v1),
real_type_tag()));
964 template <
typename T>
971 return std::log(T(1) + v);
974 return (T(-0.5) * v + T(1)) *
v;
977 return std::numeric_limits<T>::quiet_NaN();
980 template <
typename T>
985 return std::log(T(1) + v);
988 return std::numeric_limits<T>::quiet_NaN();
991 template <
typename T>
995 return std::numeric_limits<T>::quiet_NaN();
997 const std::size_t n =
static_cast<std::size_t
>(v1);
999 if ((v0 < T(0)) && (0 == (n % 2)))
1000 return std::numeric_limits<T>::quiet_NaN();
1005 template <
typename T>
1008 return root_impl<double>(
static_cast<double>(v0),static_cast<double>(v1),
real_type_tag());
1011 template <
typename T>
1014 return ((v < T(0)) ? std::ceil(v - T(0.5)) : std::floor(v + T(0.5)));
1017 template <
typename T>
1020 const int index = std::max<int>(0, std::min<int>(
pow10_size - 1, (int)std::floor(v1)));
1021 const T p10 = T(
pow10[index]);
1024 return T(std::ceil ((v0 * p10) - T(0.5)) / p10);
1026 return T(std::floor((v0 * p10) + T(0.5)) / p10);
1029 template <
typename T>
1035 template <
typename T>
1038 return std::sqrt((v0 * v0) + (v1 * v1));
1041 template <
typename T>
1044 return static_cast<T
>(std::sqrt(static_cast<double>((v0 * v0) + (v1 * v1))));
1047 template <
typename T>
1053 template <
typename T>
1059 template <
typename T>
1062 return v0 * (T(1) /
std::pow(T(2),static_cast<T>(static_cast<int>(v1))));
1065 template <
typename T>
1071 template <
typename T>
1074 return v0 *
std::pow(T(2),static_cast<T>(static_cast<int>(v1)));
1077 template <
typename T>
1083 template <
typename T>
1086 if (v > T(0))
return T(+1);
1087 else if (v < T(0))
return T(-1);
1091 template <
typename T>
1094 if (v > T(0))
return T(+1);
1095 else if (v < T(0))
return T(-1);
1099 template <
typename T>
1105 template <
typename T>
1111 template <
typename T>
1117 template <
typename T>
1123 template <
typename T>
1129 template <
typename T>
1135 template <
typename T>
1141 template <
typename T>
1147 template <
typename T>
1153 template <
typename T>
1159 template <
typename T>
1165 if ((v0_true && v1_true) || (!v0_true && !v1_true))
1171 template <
typename T>
1177 if ((v0_true && v1_true) || (!v0_true && !v1_true))
1183 #if (defined(_MSC_VER) && (_MSC_VER >= 1900)) || !defined(_MSC_VER)
1184 #define exprtk_define_erf(TT,impl) \
1185 inline TT erf_impl(TT v) { return impl(v); } \
1190 #undef exprtk_define_erf
1193 template <
typename T>
1196 #if defined(_MSC_VER) && (_MSC_VER < 1900)
1198 static const T c[] = {
1199 T( 1.26551223), T(1.00002368),
1200 T( 0.37409196), T(0.09678418),
1201 T(-0.18628806), T(0.27886807),
1202 T(-1.13520398), T(1.48851587),
1203 T(-0.82215223), T(0.17087277)
1208 T result = T(1) - t * std::exp((-v * v) -
1209 c[0] + t * (c[1] + t *
1210 (c[2] + t * (c[3] + t *
1211 (c[4] + t * (c[5] + t *
1212 (c[6] + t * (c[7] + t *
1213 (c[8] + t * (c[9]))))))))));
1215 return (v >= T(0)) ? result : -result;
1221 template <
typename T>
1227 #if (defined(_MSC_VER) && (_MSC_VER >= 1900)) || !defined(_MSC_VER)
1228 #define exprtk_define_erfc(TT,impl) \
1229 inline TT erfc_impl(TT v) { return impl(v); } \
1234 #undef exprtk_define_erfc
1237 template <
typename T>
1240 #if defined(_MSC_VER) && (_MSC_VER < 1900)
1247 template <
typename T>
1253 template <
typename T>
1259 return (v < T(0)) ? (T(1) - cnd) : cnd;
1262 template <
typename T>
1268 template <
typename T>
1271 if (std::abs(v) >= std::numeric_limits<T>::epsilon())
1272 return(std::sin(v) / v);
1277 template <
typename T>
1348 template <
typename T>
1351 return std::equal_to<T>()(T(0),std::fmod(v,T(1)));
1354 template <
typename T>
1361 template <
typename Type>
1369 template <
typename T>
1376 template <
typename T>
1383 template <
typename T>
1390 template <
typename T>
1391 inline T
min(
const T v0,
const T v1)
1397 template <
typename T>
1398 inline T
max(
const T v0,
const T v1)
1404 template <
typename T>
1411 template <
typename T>
1418 template <
typename T>
1425 template <
typename T>
1426 inline T
pow(
const T v0,
const T v1)
1432 template <
typename T>
1433 inline T
logn(
const T v0,
const T v1)
1439 template <
typename T>
1440 inline T
root(
const T v0,
const T v1)
1446 template <
typename T>
1453 template <
typename T>
1460 template <
typename T>
1467 template <
typename T>
1468 inline T
shr(
const T v0,
const T v1)
1474 template <
typename T>
1475 inline T
shl(
const T v0,
const T v1)
1481 template <
typename T>
1488 template <
typename T>
1495 template <
typename T>
1499 return or_impl(v0, v1, num_type);
1502 template <
typename T>
1509 template <
typename T>
1516 template <
typename T>
1523 template <
typename T>
1530 template <
typename T,
unsigned int N>
1560 template <
typename T>
struct fast_exp<T, 4> {
static inline T
result(T
v) { T v_2 = v *
v;
return v_2 * v_2; } };
1561 template <
typename T>
struct fast_exp<T, 3> {
static inline T
result(T
v) {
return v * v *
v; } };
1564 template <
typename T>
struct fast_exp<T, 0> {
static inline T
result(T ) {
return T(1); } };
1566 #define exprtk_define_unary_function(FunctionName) \
1567 template <typename T> \
1568 inline T FunctionName (const T v) \
1570 const typename details::number_type<T>::type num_type; \
1571 return FunctionName##_impl(v,num_type); \
1614 #undef exprtk_define_unary_function
1617 template <
typename T>
1620 static const double fract10[] =
1623 1.0E+001, 1.0E+002, 1.0E+003, 1.0E+004, 1.0E+005, 1.0E+006, 1.0E+007, 1.0E+008, 1.0E+009, 1.0E+010,
1624 1.0E+011, 1.0E+012, 1.0E+013, 1.0E+014, 1.0E+015, 1.0E+016, 1.0E+017, 1.0E+018, 1.0E+019, 1.0E+020,
1625 1.0E+021, 1.0E+022, 1.0E+023, 1.0E+024, 1.0E+025, 1.0E+026, 1.0E+027, 1.0E+028, 1.0E+029, 1.0E+030,
1626 1.0E+031, 1.0E+032, 1.0E+033, 1.0E+034, 1.0E+035, 1.0E+036, 1.0E+037, 1.0E+038, 1.0E+039, 1.0E+040,
1627 1.0E+041, 1.0E+042, 1.0E+043, 1.0E+044, 1.0E+045, 1.0E+046, 1.0E+047, 1.0E+048, 1.0E+049, 1.0E+050,
1628 1.0E+051, 1.0E+052, 1.0E+053, 1.0E+054, 1.0E+055, 1.0E+056, 1.0E+057, 1.0E+058, 1.0E+059, 1.0E+060,
1629 1.0E+061, 1.0E+062, 1.0E+063, 1.0E+064, 1.0E+065, 1.0E+066, 1.0E+067, 1.0E+068, 1.0E+069, 1.0E+070,
1630 1.0E+071, 1.0E+072, 1.0E+073, 1.0E+074, 1.0E+075, 1.0E+076, 1.0E+077, 1.0E+078, 1.0E+079, 1.0E+080,
1631 1.0E+081, 1.0E+082, 1.0E+083, 1.0E+084, 1.0E+085, 1.0E+086, 1.0E+087, 1.0E+088, 1.0E+089, 1.0E+090,
1632 1.0E+091, 1.0E+092, 1.0E+093, 1.0E+094, 1.0E+095, 1.0E+096, 1.0E+097, 1.0E+098, 1.0E+099, 1.0E+100,
1633 1.0E+101, 1.0E+102, 1.0E+103, 1.0E+104, 1.0E+105, 1.0E+106, 1.0E+107, 1.0E+108, 1.0E+109, 1.0E+110,
1634 1.0E+111, 1.0E+112, 1.0E+113, 1.0E+114, 1.0E+115, 1.0E+116, 1.0E+117, 1.0E+118, 1.0E+119, 1.0E+120,
1635 1.0E+121, 1.0E+122, 1.0E+123, 1.0E+124, 1.0E+125, 1.0E+126, 1.0E+127, 1.0E+128, 1.0E+129, 1.0E+130,
1636 1.0E+131, 1.0E+132, 1.0E+133, 1.0E+134, 1.0E+135, 1.0E+136, 1.0E+137, 1.0E+138, 1.0E+139, 1.0E+140,
1637 1.0E+141, 1.0E+142, 1.0E+143, 1.0E+144, 1.0E+145, 1.0E+146, 1.0E+147, 1.0E+148, 1.0E+149, 1.0E+150,
1638 1.0E+151, 1.0E+152, 1.0E+153, 1.0E+154, 1.0E+155, 1.0E+156, 1.0E+157, 1.0E+158, 1.0E+159, 1.0E+160,
1639 1.0E+161, 1.0E+162, 1.0E+163, 1.0E+164, 1.0E+165, 1.0E+166, 1.0E+167, 1.0E+168, 1.0E+169, 1.0E+170,
1640 1.0E+171, 1.0E+172, 1.0E+173, 1.0E+174, 1.0E+175, 1.0E+176, 1.0E+177, 1.0E+178, 1.0E+179, 1.0E+180,
1641 1.0E+181, 1.0E+182, 1.0E+183, 1.0E+184, 1.0E+185, 1.0E+186, 1.0E+187, 1.0E+188, 1.0E+189, 1.0E+190,
1642 1.0E+191, 1.0E+192, 1.0E+193, 1.0E+194, 1.0E+195, 1.0E+196, 1.0E+197, 1.0E+198, 1.0E+199, 1.0E+200,
1643 1.0E+201, 1.0E+202, 1.0E+203, 1.0E+204, 1.0E+205, 1.0E+206, 1.0E+207, 1.0E+208, 1.0E+209, 1.0E+210,
1644 1.0E+211, 1.0E+212, 1.0E+213, 1.0E+214, 1.0E+215, 1.0E+216, 1.0E+217, 1.0E+218, 1.0E+219, 1.0E+220,
1645 1.0E+221, 1.0E+222, 1.0E+223, 1.0E+224, 1.0E+225, 1.0E+226, 1.0E+227, 1.0E+228, 1.0E+229, 1.0E+230,
1646 1.0E+231, 1.0E+232, 1.0E+233, 1.0E+234, 1.0E+235, 1.0E+236, 1.0E+237, 1.0E+238, 1.0E+239, 1.0E+240,
1647 1.0E+241, 1.0E+242, 1.0E+243, 1.0E+244, 1.0E+245, 1.0E+246, 1.0E+247, 1.0E+248, 1.0E+249, 1.0E+250,
1648 1.0E+251, 1.0E+252, 1.0E+253, 1.0E+254, 1.0E+255, 1.0E+256, 1.0E+257, 1.0E+258, 1.0E+259, 1.0E+260,
1649 1.0E+261, 1.0E+262, 1.0E+263, 1.0E+264, 1.0E+265, 1.0E+266, 1.0E+267, 1.0E+268, 1.0E+269, 1.0E+270,
1650 1.0E+271, 1.0E+272, 1.0E+273, 1.0E+274, 1.0E+275, 1.0E+276, 1.0E+277, 1.0E+278, 1.0E+279, 1.0E+280,
1651 1.0E+281, 1.0E+282, 1.0E+283, 1.0E+284, 1.0E+285, 1.0E+286, 1.0E+287, 1.0E+288, 1.0E+289, 1.0E+290,
1652 1.0E+291, 1.0E+292, 1.0E+293, 1.0E+294, 1.0E+295, 1.0E+296, 1.0E+297, 1.0E+298, 1.0E+299, 1.0E+300,
1653 1.0E+301, 1.0E+302, 1.0E+303, 1.0E+304, 1.0E+305, 1.0E+306, 1.0E+307, 1.0E+308
1656 static const int fract10_size =
static_cast<int>(
sizeof(fract10) /
sizeof(
double));
1658 const int e = std::abs(exponent);
1660 if (exponent >= std::numeric_limits<T>::min_exponent10)
1662 if (e < fract10_size)
1665 return T(d * fract10[e]);
1667 return T(d / fract10[e]);
1670 return T(d *
std::pow(10.0, 10.0 * exponent));
1674 d /= T(fract10[ -std::numeric_limits<T>::min_exponent10]);
1675 return T(d / fract10[-exponent + std::numeric_limits<T>::min_exponent10]);
1679 template <
typename Iterator,
typename T>
1685 const bool negative = (
'-' == (*itr));
1687 if (negative || (
'+' == (*itr)))
1695 while ((end != itr) && (zero == (*itr))) ++itr;
1697 bool return_result =
true;
1698 unsigned int digit = 0;
1699 const std::size_t length =
static_cast<std::size_t
>(std::distance(itr,end));
1706 #ifdef exprtk_use_lut
1708 #define exprtk_process_digit \
1709 if ((digit = details::digit_table[(int)*itr++]) < 10) \
1710 result = result * 10 + (digit); \
1713 return_result = false; \
1719 #define exprtk_process_digit \
1720 if ((digit = (*itr++ - zero)) < 10) \
1721 result = result * T(10) + digit; \
1724 return_result = false; \
1733 case 1 :
if ((digit = (*itr - zero))>= 10) { digit = 0; return_result =
false; }
1735 #undef exprtk_process_digit
1740 return_result =
false;
1742 if (length && return_result)
1744 result = result * 10 +
static_cast<T
>(digit);
1748 result = negative ? -result : result;
1749 return return_result;
1752 template <
typename Iterator,
typename T>
1753 static inline bool parse_nan(Iterator& itr,
const Iterator end, T&
t)
1755 typedef typename std::iterator_traits<Iterator>::value_type type;
1757 static const std::size_t nan_length = 3;
1759 if (std::distance(itr,end) != static_cast<int>(nan_length))
1762 if (static_cast<type>(
'n') == (*itr))
1765 (static_cast<type>(
'a') != *(itr + 1)) ||
1766 (static_cast<type>(
'n') != *(itr + 2))
1773 (static_cast<type>(
'A') != *(itr + 1)) ||
1774 (static_cast<type>(
'N') != *(itr + 2))
1780 t = std::numeric_limits<T>::quiet_NaN();
1785 template <
typename Iterator,
typename T>
1786 static inline bool parse_inf(Iterator& itr,
const Iterator end, T&
t,
bool negative)
1788 static const char_t inf_uc[] =
"INFINITY";
1789 static const char_t inf_lc[] =
"infinity";
1790 static const std::size_t inf_length = 8;
1792 const std::size_t length =
static_cast<std::size_t
>(std::distance(itr,end));
1794 if ((3 != length) && (inf_length != length))
1797 char_cptr inf_itr = (
'i' == (*itr)) ? inf_lc : inf_uc;
1801 if (*inf_itr == static_cast<char>(*itr))
1812 t = -std::numeric_limits<T>::infinity();
1814 t = std::numeric_limits<T>::infinity();
1819 template <
typename Iterator,
typename T>
1822 if (end == itr_external)
return false;
1824 Iterator itr = itr_external;
1828 const bool negative = (
'-' == (*itr));
1830 if (negative ||
'+' == (*itr))
1836 bool instate =
false;
1838 static const char zero =
static_cast<uchar_t>(
'0');
1840 #define parse_digit_1(d) \
1841 if ((digit = (*itr - zero)) < 10) \
1842 { d = d * T(10) + digit; } \
1845 if (end == ++itr) break; \
1847 #define parse_digit_2(d) \
1848 if ((digit = (*itr - zero)) < 10) \
1849 { d = d * T(10) + digit; } \
1855 const Iterator curr = itr;
1857 while ((end != itr) && (zero == (*itr))) ++itr;
1865 #ifdef exprtk_enable_superscalar
1874 if (curr != itr) instate =
true;
1883 const Iterator curr = ++itr;
1889 #ifdef exprtk_enable_superscalar
1902 d +=
compute_pow10(tmp_d,static_cast<int>(-std::distance(curr,itr)));
1905 #undef parse_digit_1
1906 #undef parse_digit_2
1911 typename std::iterator_traits<Iterator>::value_type c = (*itr);
1913 if ((
'e' == c) || (
'E' == c))
1930 if ((
'f' == c) || (
'F' == c) || (
'l' == c) || (
'L' == c))
1936 else if ((
'I' <= (*itr)) && ((*itr) <=
'n'))
1938 if ((
'i' == (*itr)) || (
'I' == (*itr)))
1940 return parse_inf(itr, end, t, negative);
1942 else if ((
'n' == (*itr)) || (
'N' == (*itr)))
1952 else if ((
'I' <= (*itr)) && ((*itr) <=
'n'))
1954 if ((
'i' == (*itr)) || (
'I' == (*itr)))
1956 return parse_inf(itr, end, t, negative);
1958 else if ((
'n' == (*itr)) || (
'N' == (*itr)))
1971 if ((end != itr) || (!instate))
1976 t =
static_cast<T
>((negative) ? -d : d);
1980 template <
typename T>
1991 template <
typename T>
2046 template <
typename Iterator>
2048 const Iterator begin,
const Iterator end,
2049 const Iterator base_begin = Iterator(0))
2052 value.assign(begin,end);
2054 position =
static_cast<std::size_t
>(std::distance(base_begin,begin));
2058 template <
typename Iterator>
2059 inline token&
set_symbol(
const Iterator begin,
const Iterator end,
const Iterator base_begin = Iterator(0))
2062 value.assign(begin,end);
2064 position =
static_cast<std::size_t
>(std::distance(base_begin,begin));
2068 template <
typename Iterator>
2069 inline token&
set_numeric(
const Iterator begin,
const Iterator end,
const Iterator base_begin = Iterator(0))
2072 value.assign(begin,end);
2074 position =
static_cast<std::size_t
>(std::distance(base_begin,begin));
2078 template <
typename Iterator>
2079 inline token&
set_string(
const Iterator begin,
const Iterator end,
const Iterator base_begin = Iterator(0))
2082 value.assign(begin,end);
2084 position =
static_cast<std::size_t
>(std::distance(base_begin,begin));
2096 template <
typename Iterator>
2098 const Iterator begin,
const Iterator end,
2099 const Iterator base_begin = Iterator(0))
2114 value.assign(begin,end);
2117 position =
static_cast<std::size_t
>(std::distance(base_begin,begin));
2126 case e_none :
return "NONE";
2127 case e_error :
return "ERROR";
2131 case e_eof :
return "EOF";
2141 case e_shr :
return ">>";
2142 case e_shl :
return "<<";
2143 case e_lte :
return "<=";
2144 case e_ne :
return "!=";
2145 case e_gte :
return ">=";
2146 case e_lt :
return "<";
2147 case e_gt :
return ">";
2148 case e_eq :
return "=";
2156 case e_add :
return "+";
2157 case e_sub :
return "-";
2158 case e_div :
return "/";
2159 case e_mul :
return "*";
2160 case e_mod :
return "%";
2161 case e_pow :
return "^";
2164 case e_swap :
return "<=>";
2165 default :
return "UNKNOWN";
2216 s_end_ = str.data() + str.size();
2313 inline std::string
substr(
const std::size_t& begin,
const std::size_t& end)
2318 return std::string(begin_itr,end_itr);
2340 #ifndef exprtk_disable_comments
2341 const char_t c0 = *(itr + 0);
2342 const char_t c1 = *(itr + 1);
2346 else if (!
is_end(itr + 1))
2348 if ((
'/' == c0) && (
'/' == c1))
return true;
2349 if ((
'/' == c0) && (
'*' == c1))
return true;
2365 #ifndef exprtk_disable_comments
2372 static inline bool comment_start(
const char_t c0,
const char_t c1,
int& mode,
int& incr)
2375 if (
'#' == c0) { mode = 1; incr = 1; }
2378 if (
'/' == c1) { mode = 1; incr = 2; }
2379 else if (
'*' == c1) { mode = 2; incr = 2; }
2384 static inline bool comment_end(
const char_t c0,
const char_t c1,
int& mode)
2387 ((1 == mode) && (
'\n' == c0)) ||
2388 ((2 == mode) && (
'*' == c0) && (
'/' == c1))
2404 else if (!test::comment_start(*
s_itr_, *(
s_itr_ + 1), mode, increment))
2413 if ((1 == mode) && test::comment_end(*
s_itr_, 0, mode))
2467 else if (
'$' == (*
s_itr_))
2472 #ifndef exprtk_disable_string_capabilities
2473 else if (
'\'' == (*
s_itr_))
2479 else if (
'~' == (*
s_itr_))
2510 if ((c0 ==
'<') && (c1 ==
'=') && (c2 ==
'>'))
2577 (
s_itr_ != initial_itr) &&
2615 bool dot_found =
false;
2616 bool e_found =
false;
2617 bool post_e_sign_found =
false;
2618 bool post_e_digit_found =
false;
2637 else if (
'e' == std::tolower(*
s_itr_))
2667 if (post_e_sign_found)
2675 post_e_sign_found =
true;
2682 post_e_digit_found =
true;
2734 #ifndef exprtk_disable_string_capabilities
2749 bool escaped_found =
false;
2750 bool escaped =
false;
2754 if (!escaped && (
'\\' == *
s_itr_))
2756 escaped_found =
true;
2775 #if defined(_MSC_VER) && (_MSC_VER == 1600)
2784 const bool x_seperator = (
'x' == *(
s_itr_ + 1)) ||
2790 if (!within_range || !x_seperator || !both_digits)
2819 std::string parsed_string(initial_itr,
s_itr_);
2825 static_cast<std::size_t>(std::distance(
base_itr_,initial_itr)));
2874 throw std::invalid_argument(
"token_scanner() - Invalid stride value");
2892 if (!
operator()(t0))
2904 if (!
operator()(t0, t1))
2917 if (!
operator()(t0, t1, t2))
2931 if (!
operator()(t0, t1, t2, t3))
2975 std::size_t changes = 0;
2977 for (std::size_t i = 0; i < g.
token_list_.size(); ++i)
2997 throw std::invalid_argument(
"token_inserter() - Invalid stride value");
3008 std::size_t changes = 0;
3010 for (std::size_t i = 0; i < (g.
token_list_.size() - stride_ + 1); ++i)
3012 int insert_index = -1;
3033 typedef std::iterator_traits<generator::token_list_t::iterator>::difference_type diff_t;
3035 if ((insert_index >= 0) && (insert_index <= (static_cast<int>(stride_) + 1)))
3038 g.
token_list_.begin() +
static_cast<diff_t
>(i +
static_cast<std::size_t
>(insert_index)),
t);
3047 #define token_inserter_empty_body \
3052 inline virtual int insert(
const token&, token&)
3055 inline virtual
int insert(const token&, const token&, token&)
3058 inline virtual
int insert(const token&, const token&, const token&, token&)
3061 inline virtual
int insert(const token&, const token&, const token&, const token&, token&)
3064 inline virtual
int insert(const token&, const token&, const token&, const token&, const token&, token&)
3067 #undef token_inserter_empty_body
3071 const std::size_t stride_;
3102 typedef std::iterator_traits<generator::token_list_t::iterator>::difference_type diff_t;
3107 std::size_t changes = 0;
3109 for (std::size_t i = 0; i < (g.
token_list_.size() - 1); ++i)
3113 while (
join(g[i], g[i + 1], t))
3128 typedef std::iterator_traits<generator::token_list_t::iterator>::difference_type diff_t;
3133 std::size_t changes = 0;
3135 for (std::size_t i = 0; i < (g.
token_list_.size() - 2); ++i)
3139 while (
join(g[i], g[i + 1], g[i + 2], t))
3144 g.
token_list_.begin() +
static_cast<diff_t
>(i + 3));
3160 for (std::size_t i = 0; i < generator.
size(); ++i)
3163 printf(
"Token[%02d] @ %03d %6s --> '%s'\n",
3164 static_cast<int>(i),
3190 new_token.
value =
"*";
3199 else if (!t0.
value.empty() && (
'$' == t0.
value[0]))
3224 return (match) ? 1 : -1;
3409 using lexer::token_scanner::operator();
3440 stack_ = std::stack<std::pair<char,std::size_t> >();
3468 else if (c !=
stack_.top().first)
3486 std::stack<std::pair<char,std::size_t> >
stack_;
3494 using lexer::token_scanner::operator();
3561 bool remove(
const std::string& target_symbol)
3563 const replace_map_t::iterator itr =
replace_map_.find(target_symbol);
3574 const std::string& replace_symbol,
3577 const replace_map_t::iterator itr =
replace_map_.find(target_symbol);
3584 replace_map_[target_symbol] = std::make_pair(replace_symbol,token_type);
3607 t.
value = itr->second.first;
3608 t.
type = itr->second.second;
3624 typedef std::pair<lexer::token::token_type,lexer::token::token_type>
token_pair_t;
3629 using lexer::token_scanner::operator();
3665 const set_t::value_type p = std::make_pair(t0.
type,t1.
type);
3684 std::pair<lexer::token,lexer::token>
error(
const std::size_t index)
3693 return std::make_pair(error_token,error_token);
3736 default :
return false;
3756 default :
return true ;
3770 default :
return true ;
3780 default :
return false;
3956 inline bool init(
const std::string& str)
4029 const std::string&
value,
4063 template <
typename T>
4088 for (std::size_t i = 0; i <
data_ref_.size(); ++i)
4107 return data_[index];
4112 return data_[index];
4127 template <
typename T>
4129 const std::size_t size,
const std::size_t offset = 0)
4134 template <
typename T>
4136 const std::size_t size,
const std::size_t offset = 0)
4143 template <
typename T>
4219 template <
typename ViewType>
4293 template <
typename IntType>
4299 i =
static_cast<IntType
>(
v_);
4304 template <
typename UIntType>
4312 u =
static_cast<UIntType
>(
v_);
4321 template <
typename StringView>
4322 inline std::string
to_str(
const StringView& view)
4324 return std::string(view.begin(),view.size());
4327 #ifndef exprtk_disable_return_statement
4335 template <
typename T>
4383 #ifndef exprtk_disable_return_statement
4467 case e_add :
return "+";
4468 case e_sub :
return "-";
4469 case e_mul :
return "*";
4470 case e_div :
return "/";
4471 case e_mod :
return "%";
4472 case e_pow :
return "^";
4479 case e_lt :
return "<";
4480 case e_lte :
return "<=";
4481 case e_eq :
return "==";
4483 case e_ne :
return "!=";
4485 case e_gte :
return ">=";
4486 case e_gt :
return ">";
4487 default :
return"N/A";
4502 namespace loop_unroll
4504 #ifndef exprtk_disable_superscalar_unroll
4525 #ifdef exprtk_enable_debugging
4526 inline void dump_ptr(
const std::string& s,
const void* ptr,
const std::size_t size = 0)
4534 static_cast<unsigned int>(size)));
4537 inline void dump_ptr(
const std::string&,
const void*) {}
4538 inline void dump_ptr(
const std::string&,
const void*,
const std::size_t) {}
4541 template <
typename T>
4705 #ifdef exprtk_enable_debugging
4711 for (std::size_t i = 0; i <
size(); ++i)
4733 const std::size_t size0 = cb0->
size;
4734 const std::size_t size1 = cb1->
size;
4739 return (size0) ? size0 : size1;
4749 template <
typename T>
4754 case e_abs :
return numeric::abs (arg);
4755 case e_acos :
return numeric::acos (arg);
4756 case e_acosh :
return numeric::acosh(arg);
4757 case e_asin :
return numeric::asin (arg);
4758 case e_asinh :
return numeric::asinh(arg);
4759 case e_atan :
return numeric::atan (arg);
4760 case e_atanh :
return numeric::atanh(arg);
4761 case e_ceil :
return numeric::ceil (arg);
4762 case e_cos :
return numeric::cos (arg);
4763 case e_cosh :
return numeric::cosh (arg);
4764 case e_exp :
return numeric::exp (arg);
4765 case e_expm1 :
return numeric::expm1(arg);
4766 case e_floor :
return numeric::floor(arg);
4767 case e_log :
return numeric::log (arg);
4768 case e_log10 :
return numeric::log10(arg);
4770 case e_log1p :
return numeric::log1p(arg);
4771 case e_neg :
return numeric::neg (arg);
4772 case e_pos :
return numeric::pos (arg);
4773 case e_round :
return numeric::round(arg);
4774 case e_sin :
return numeric::sin (arg);
4775 case e_sinc :
return numeric::sinc (arg);
4776 case e_sinh :
return numeric::sinh (arg);
4777 case e_sqrt :
return numeric::sqrt (arg);
4778 case e_tan :
return numeric::tan (arg);
4779 case e_tanh :
return numeric::tanh (arg);
4780 case e_cot :
return numeric::cot (arg);
4781 case e_sec :
return numeric::sec (arg);
4782 case e_csc :
return numeric::csc (arg);
4783 case e_r2d :
return numeric::r2d (arg);
4784 case e_d2r :
return numeric::d2r (arg);
4785 case e_d2g :
return numeric::d2g (arg);
4786 case e_g2d :
return numeric::g2d (arg);
4787 case e_notl :
return numeric::notl (arg);
4788 case e_sgn :
return numeric::sgn (arg);
4789 case e_erf :
return numeric::erf (arg);
4790 case e_erfc :
return numeric::erfc (arg);
4791 case e_ncdf :
return numeric::ncdf (arg);
4792 case e_frac :
return numeric::frac (arg);
4793 case e_trunc :
return numeric::trunc(arg);
4795 default :
exprtk_debug((
"numeric::details::process_impl<T> - Invalid unary operation.\n"));
4796 return std::numeric_limits<T>::quiet_NaN();
4800 template <
typename T>
4805 case e_add :
return (arg0 + arg1);
4806 case e_sub :
return (arg0 - arg1);
4807 case e_mul :
return (arg0 * arg1);
4808 case e_div :
return (arg0 / arg1);
4809 case e_mod :
return modulus<T>(arg0,arg1);
4810 case e_pow :
return pow<T>(arg0,arg1);
4811 case e_atan2 :
return atan2<T>(arg0,arg1);
4812 case e_min :
return std::min<T>(arg0,arg1);
4813 case e_max :
return std::max<T>(arg0,arg1);
4814 case e_logn :
return logn<T>(arg0,arg1);
4815 case e_lt :
return (arg0 < arg1) ? T(1) : T(0);
4816 case e_lte :
return (arg0 <= arg1) ? T(1) : T(0);
4817 case e_eq :
return std::equal_to<T>()(arg0,arg1) ? T(1) : T(0);
4818 case e_ne :
return std::not_equal_to<T>()(arg0,arg1) ? T(1) : T(0);
4819 case e_gte :
return (arg0 >= arg1) ? T(1) : T(0);
4820 case e_gt :
return (arg0 > arg1) ? T(1) : T(0);
4821 case e_and :
return and_opr <T>(arg0,arg1);
4822 case e_nand :
return nand_opr<T>(arg0,arg1);
4823 case e_or :
return or_opr <T>(arg0,arg1);
4824 case e_nor :
return nor_opr <T>(arg0,arg1);
4825 case e_xor :
return xor_opr <T>(arg0,arg1);
4826 case e_xnor :
return xnor_opr<T>(arg0,arg1);
4827 case e_root :
return root <T>(arg0,arg1);
4828 case e_roundn :
return roundn <T>(arg0,arg1);
4831 case e_hypot :
return hypot <T>(arg0,arg1);
4832 case e_shr :
return shr <T>(arg0,arg1);
4833 case e_shl :
return shl <T>(arg0,arg1);
4835 default :
exprtk_debug((
"numeric::details::process_impl<T> - Invalid binary operation.\n"));
4836 return std::numeric_limits<T>::quiet_NaN();
4840 template <
typename T>
4845 case e_add :
return (arg0 + arg1);
4846 case e_sub :
return (arg0 - arg1);
4847 case e_mul :
return (arg0 * arg1);
4848 case e_div :
return (arg0 / arg1);
4849 case e_mod :
return arg0 % arg1;
4850 case e_pow :
return pow<T>(arg0,arg1);
4851 case e_min :
return std::min<T>(arg0,arg1);
4852 case e_max :
return std::max<T>(arg0,arg1);
4853 case e_logn :
return logn<T>(arg0,arg1);
4854 case e_lt :
return (arg0 < arg1) ? T(1) : T(0);
4855 case e_lte :
return (arg0 <= arg1) ? T(1) : T(0);
4856 case e_eq :
return (arg0 == arg1) ? T(1) : T(0);
4857 case e_ne :
return (arg0 != arg1) ? T(1) : T(0);
4858 case e_gte :
return (arg0 >= arg1) ? T(1) : T(0);
4859 case e_gt :
return (arg0 > arg1) ? T(1) : T(0);
4860 case e_and :
return ((arg0 != T(0)) && (arg1 != T(0))) ? T(1) : T(0);
4861 case e_nand :
return ((arg0 != T(0)) && (arg1 != T(0))) ? T(0) : T(1);
4862 case e_or :
return ((arg0 != T(0)) || (arg1 != T(0))) ? T(1) : T(0);
4863 case e_nor :
return ((arg0 != T(0)) || (arg1 != T(0))) ? T(0) : T(1);
4864 case e_xor :
return arg0 ^ arg1;
4865 case e_xnor :
return !(arg0 ^ arg1);
4866 case e_root :
return root<T>(arg0,arg1);
4867 case e_equal :
return arg0 == arg1;
4868 case e_nequal :
return arg0 != arg1;
4869 case e_hypot :
return hypot<T>(arg0,arg1);
4870 case e_shr :
return arg0 >> arg1;
4871 case e_shl :
return arg0 << arg1;
4873 default :
exprtk_debug((
"numeric::details::process_impl<IntType> - Invalid binary operation.\n"));
4874 return std::numeric_limits<T>::quiet_NaN();
4879 template <
typename T>
4885 template <
typename T>
4892 template <
typename T>
4946 return std::numeric_limits<T>::quiet_NaN();
4960 template <
typename T>
4965 return std::not_equal_to<double>()(0.0,v);
4970 return std::not_equal_to<long double>()(0.0L,v);
4975 return std::not_equal_to<float>()(0.0f,v);
4978 template <
typename T>
4981 return std::not_equal_to<std::complex<T> >()(std::complex<T>(0),
v);
4984 template <
typename T>
4987 return std::not_equal_to<T>()(T(0),node->
value());
4990 template <
typename T>
4993 return std::equal_to<T>()(T(0),node->
value());
4996 template <
typename T>
5002 template <
typename T>
5008 template <
typename T>
5014 template <
typename T>
5020 template <
typename T>
5032 template <
typename T>
5038 template <
typename T>
5044 template <
typename T>
5050 template <
typename T>
5056 template <
typename T>
5061 switch (node->
type())
5073 default :
return false;
5080 template <
typename T>
5086 template <
typename T>
5092 template <
typename T>
5098 template <
typename T>
5104 template <
typename T>
5110 template <
typename T>
5116 template <
typename T>
5124 template <
typename T>
5135 template <
typename T>
5142 template <std::
size_t N,
typename T>
5145 for (std::size_t i = 0; i < N; ++i)
5147 if (0 == b[i])
return false;
5153 template <
typename T,
5155 template <
typename,
typename>
class Sequence>
5158 for (std::size_t i = 0; i < b.size(); ++i)
5160 if (0 == b[i])
return false;
5166 template <std::
size_t N,
typename T>
5169 for (std::size_t i = 0; i < N; ++i)
5180 template <
typename T,
5182 template <
typename,
typename>
class Sequence>
5185 for (std::size_t i = 0; i < b.size(); ++i)
5196 template <
typename NodeAllocator,
typename T, std::
size_t N>
5199 for (std::size_t i = 0; i < N; ++i)
5205 template <
typename NodeAllocator,
5208 template <
typename,
typename>
class Sequence>
5211 for (std::size_t i = 0; i < b.size(); ++i)
5219 template <
typename NodeAllocator,
typename T>
5230 node_allocator.free(node);
5235 template <
typename T>
5242 template <
typename Type>
5317 template <
typename Allocator,
5318 template <
typename,
typename>
class Sequence>
5399 template <
typename Allocator>
5439 template <
typename T>
5446 return std::numeric_limits<T>::quiet_NaN();
5455 template <
typename T>
5509 template <
typename T>
5541 template <
typename T>
5544 template <
typename T>
5547 template <
typename T>
5562 #ifndef exprtk_disable_string_capabilities
5563 template <
typename T>
5573 virtual std::string
str ()
const = 0;
5577 virtual std::size_t
size()
const = 0;
5580 template <
typename T>
5592 rp_.
n0_c = std::make_pair<bool,std::size_t>(
true,0);
5593 rp_.
n1_c = std::make_pair<bool,std::size_t>(
true,v.size() - 1);
5600 return std::numeric_limits<T>::quiet_NaN();
5648 template <
typename T>
5704 template <
typename T, std::
size_t D,
bool B>
5707 template <std::
size_t N>
5712 template <
typename T, std::
size_t D>
5715 template <std::
size_t N>
5725 template <std::
size_t N,
typename T>
5752 template <
typename T, std::
size_t N>
5755 for (std::size_t i = 0; i < N; ++i)
5757 if (branch[i].first && branch[i].second)
5764 template <
typename T,
5766 template <
typename,
typename>
class Sequence>
5769 for (std::size_t i = 0; i < branch.size(); ++i)
5771 if (branch[i].first && branch[i].second)
5779 template <
typename T>
5792 init_branches<2>(
branch_, branch0, branch1);
5797 cleanup_branches::execute<T,2>(
branch_);
5802 const T arg0 =
branch_[0].first->value();
5803 const T arg1 =
branch_[1].first->value();
5805 return numeric::process<T>(
operation_,arg0,arg1);
5822 else if (1 == index)
5834 template <
typename T,
typename Operation>
5844 init_branches<2>(
branch_, branch0, branch1);
5849 cleanup_branches::execute<T,2>(
branch_);
5854 const T arg0 =
branch_[0].first->value();
5855 const T arg1 =
branch_[1].first->value();
5867 return Operation::operation();
5874 else if (1 == index)
5885 template <
typename T>
5899 init_branches<3>(
branch_, branch0, branch1, branch2);
5904 cleanup_branches::execute<T,3>(
branch_);
5909 const T arg0 =
branch_[0].first->value();
5910 const T arg1 =
branch_[1].first->value();
5911 const T arg2 =
branch_[2].first->value();
5915 case e_inrange :
return (arg1 < arg0) ? T(0) : ((arg1 > arg2) ? T(0) : T(1));
5917 case e_clamp :
return (arg1 < arg0) ? arg0 : (arg1 > arg2 ? arg2 : arg1);
5919 case e_iclamp :
if ((arg1 <= arg0) || (arg1 >= arg2))
5922 return ((T(2) * arg1 <= (arg2 + arg0)) ? arg0 : arg2);
5924 default :
exprtk_debug((
"trinary_node::value() - Error: Invalid operation\n"));
5925 return std::numeric_limits<T>::quiet_NaN();
5940 template <
typename T>
5955 init_branches<4>(
branch_, branch0, branch1, branch2, branch3);
5960 cleanup_branches::execute<T,4>(
branch_);
5965 return std::numeric_limits<T>::quiet_NaN();
5979 template <
typename T>
6038 template <
typename T>
6072 return std::numeric_limits<T>::quiet_NaN();
6088 #ifndef exprtk_disable_break_continue
6089 template <
typename T>
6104 template <
typename T>
6128 return std::numeric_limits<T>::quiet_NaN();
6143 template <
typename T>
6152 return std::numeric_limits<T>::quiet_NaN();
6163 template <
typename T>
6215 template <
typename T>
6268 template <
typename T>
6355 #ifndef exprtk_disable_break_continue
6356 template <
typename T>
6417 template <
typename T>
6479 template <
typename T>
6586 template <
typename T>
6593 template <
typename Allocator,
6594 template <
typename,
typename>
class Sequence>
6597 if (1 != (arg_list.size() & 1))
6603 for (std::size_t i = 0; i < arg_list.size(); ++i)
6621 for (std::size_t i = 0; i <
arg_list_.size(); ++i)
6634 const std::size_t upper_bound = (
arg_list_.size() - 1);
6636 for (std::size_t i = 0; i < upper_bound; i += 2)
6643 return consequent->
value();
6650 return std::numeric_limits<T>::quiet_NaN();
6664 template <
typename T,
typename Switch_N>
6671 template <
typename Allocator,
6672 template <
typename,
typename>
class Sequence>
6683 template <
typename T>
6690 template <
typename Allocator,
6691 template <
typename,
typename>
class Sequence>
6694 if (0 != (arg_list.size() & 1))
6700 for (std::size_t i = 0; i < arg_list.size(); ++i)
6718 for (std::size_t i = 0; i <
arg_list_.size(); ++i)
6733 return std::numeric_limits<T>::quiet_NaN();
6736 const std::size_t upper_bound = (
arg_list_.size() - 1);
6738 for (std::size_t i = 0; i < upper_bound; i += 2)
6745 result = consequent->
value();
6763 template <
typename T>
6771 virtual T&
ref() = 0;
6772 virtual const T&
ref()
const = 0;
6775 template <
typename T>
6791 inline bool operator <(const variable_node<T>&
v)
const
6821 template <
typename T>
6824 template <
typename T>
6833 n0_c (std::make_pair(false,0)),
6834 n1_c (std::make_pair(false,0)),
6835 cache(std::make_pair(0,0))
6842 n0_c = std::make_pair(
false,0);
6843 n1_c = std::make_pair(
false,0);
6844 cache = std::make_pair(0,0);
6878 return (
n0_c.first &&
n1_c.first) &&
6884 return (
n0_e.first &&
n1_e.first) &&
6892 else if (
n0_e.first)
6894 T r0_value =
n0_e.second->value();
6906 else if (
n1_e.first)
6908 T r1_value =
n1_e.second->value();
6934 return (
n1_c.second -
n0_c.second + 1);
6942 std::pair<bool,expression_node_ptr>
n0_e;
6943 std::pair<bool,expression_node_ptr>
n1_e;
6949 template <
typename T>
6952 template <
typename T>
6975 template <
typename T>
6986 virtual std::size_t
size ()
const = 0;
6994 virtual const vds_t&
vds ()
const = 0;
6999 template <
typename T>
7000 class vector_node :
public expression_node <T>,
7001 public vector_interface<T>
7068 template <
typename T>
7126 template <
typename T>
7187 template <
typename T>
7238 template <
typename T>
7246 const std::size_t& size,
7247 const std::vector<expression_ptr>& initialiser_list,
7248 const bool single_value_initialse)
7270 for (std::size_t i = 0; i <
size_; ++i)
7279 for (std::size_t i = 0; i < il_size; ++i)
7284 if (il_size <
size_)
7286 for (std::size_t i = il_size; i <
size_; ++i)
7311 template <
typename T>
7341 template <
typename T>
7372 template <
typename T>
7430 for (std::size_t i = 0; i <
vec_size_; ++i)
7438 return std::numeric_limits<T>::quiet_NaN();
7480 #ifndef exprtk_disable_string_capabilities
7481 template <
typename T>
7499 rp_.
n0_c = std::make_pair<bool,std::size_t>(
true,0);
7500 rp_.
n1_c = std::make_pair<bool,std::size_t>(
true,v.size() - 1);
7505 inline bool operator <(const stringvar_node<T>&
v)
const
7512 rp_.
n1_c.second = (*value_).size() - 1;
7515 return std::numeric_limits<T>::quiet_NaN();
7525 return &(*value_)[0];
7530 return ref().size();
7538 const std::string&
ref()
const
7564 template <
typename T>
7567 template <
typename T>
7588 inline bool operator <(const string_range_node<T>&
v)
const
7595 return std::numeric_limits<T>::quiet_NaN();
7598 inline std::string
str()
const
7605 return &(*value_)[0];
7610 return ref().size();
7618 inline virtual std::string&
ref()
7623 inline virtual const std::string&
ref()
const
7649 template <
typename T>
7652 template <
typename T>
7673 return std::numeric_limits<T>::quiet_NaN();
7719 template <
typename T>
7742 range_.
n0_c = std::make_pair<bool,std::size_t>(
true,0);
7743 range_.
n1_c = std::make_pair<bool,std::size_t>(
true,0);
7779 std::size_t str_r0 = 0;
7780 std::size_t str_r1 = 0;
7790 range (str_r0,str_r1,base_str_size) &&
7794 const std::size_t
size = (r1 - r0) + 1;
7803 return std::numeric_limits<T>::quiet_NaN();
7848 template <
typename T>
7872 range_.
n0_c = std::make_pair<bool,std::size_t>(
true,0);
7873 range_.
n1_c = std::make_pair<bool,std::size_t>(
true,0);
7917 std::size_t str0_r0 = 0;
7918 std::size_t str0_r1 = 0;
7920 std::size_t str1_r0 = 0;
7921 std::size_t str1_r1 = 0;
7931 const std::size_t size0 = (str0_r1 - str0_r0) + 1;
7932 const std::size_t size1 = (str1_r1 - str1_r0) + 1;
7942 return std::numeric_limits<T>::quiet_NaN();
7986 template <
typename T>
8030 return std::numeric_limits<T>::quiet_NaN();
8070 template <
typename T>
8134 std::size_t str0_r0 = 0;
8135 std::size_t str0_r1 = 0;
8137 std::size_t str1_r0 = 0;
8138 std::size_t str1_r1 = 0;
8140 range_t& range0 = (*str0_range_ptr_);
8141 range_t& range1 = (*str1_range_ptr_);
8148 const std::size_t size0 = range0.
cache_size();
8149 const std::size_t size1 = range1.
cache_size();
8150 const std::size_t max_size =
std::min(size0,size1);
8158 while (s0 < upper_bound)
8160 #define exprtk_loop(N) \
8161 std::swap(s0[N], s1[N]); \
8165 #ifndef exprtk_disable_superscalar_unroll
8183 #define case_stmt(N) \
8184 case N : { std::swap(s0[i],s1[i]); ++i; } \
8186 #ifndef exprtk_disable_superscalar_unroll
8204 return std::numeric_limits<T>::quiet_NaN();
8224 template <
typename T>
8241 return T((*value_).size());
8254 template <
typename T>
8257 template <
typename T>
8289 T result = std::numeric_limits<T>::quiet_NaN();
8315 { s.assign(data,size); }
8321 { s.append(data,size); }
8324 template <
typename T,
typename AssignmentProcess = asn_assignment>
8386 range_t& range = (*str1_range_ptr_);
8398 return std::numeric_limits<T>::quiet_NaN();
8440 template <
typename T,
typename AssignmentProcess = asn_assignment>
8509 std::size_t s0_r0 = 0;
8510 std::size_t s0_r1 = 0;
8512 std::size_t s1_r0 = 0;
8513 std::size_t s1_r1 = 0;
8515 range_t& range0 = (*str0_range_ptr_);
8516 range_t& range1 = (*str1_range_ptr_);
8523 std::size_t
size =
std::min((s0_r1 - s0_r0),(s1_r1 - s1_r0)) + 1;
8531 return std::numeric_limits<T>::quiet_NaN();
8574 template <
typename T>
8601 range_.
n0_c = std::make_pair<bool,std::size_t>(
true,0);
8602 range_.
n1_c = std::make_pair<bool,std::size_t>(
true,0);
8655 const std::size_t
size = (r1 - r0) + 1;
8673 const std::size_t
size = (r1 - r0) + 1;
8685 return std::numeric_limits<T>::quiet_NaN();
8733 template <
typename T>
8756 range_.
n0_c = std::make_pair<bool,std::size_t>(
true,0);
8757 range_.
n1_c = std::make_pair<bool,std::size_t>(
true,0);
8793 const std::size_t
size = (r1 - r0) + 1;
8805 return std::numeric_limits<T>::quiet_NaN();
8850 template <
typename T,
typename VarArgFunction>
8864 template <
typename Allocator,
8865 template <
typename,
typename>
class Sequence>
8890 if (arg_list.size() > 1)
8892 const std::size_t arg_list_size = arg_list.size() - 1;
8897 for (std::size_t i = 0; i < arg_list_size; ++i)
8921 for (std::size_t i = 0; i <
arg_list_.size(); ++i)
8939 return std::numeric_limits<T>::quiet_NaN();
8984 template <
typename T, std::
size_t N>
8991 template <
typename T, std::
size_t N>
8998 template <
typename T>
9009 #define define_sfop3(NN,OP0,OP1) \
9010 template <typename T> \
9011 struct sf##NN##_op : public sf_base<T> \
9013 typedef typename sf_base<T>::Type Type; \
9014 static inline T process(Type x, Type y, Type z) \
9018 static inline std::string id() \
9027 define_sfop3(03,(
x + y) + z ,"(
t+
t)+
t")
9028 define_sfop3(04,(
x - y) + z ,"(
t-
t)+
t")
9029 define_sfop3(05,(
x - y) / z ,"(
t-
t)/
t")
9030 define_sfop3(06,(
x - y) * z ,"(
t-
t)*
t")
9031 define_sfop3(07,(
x * y) + z ,"(
t*
t)+
t")
9032 define_sfop3(08,(
x * y) - z ,"(
t*
t)-
t")
9033 define_sfop3(09,(
x * y) / z ,"(
t*
t)/
t")
9034 define_sfop3(10,(
x * y) * z ,"(
t*
t)*
t")
9035 define_sfop3(11,(
x / y) + z ,"(
t/
t)+
t")
9036 define_sfop3(12,(
x / y) - z ,"(
t/
t)-
t")
9037 define_sfop3(13,(
x / y) / z ,"(
t/
t)/
t")
9038 define_sfop3(14,(
x / y) * z ,"(
t/
t)*
t")
9039 define_sfop3(15,
x / (y + z) ,"
t/(
t+
t)")
9040 define_sfop3(16,
x / (y - z) ,"
t/(
t-
t)")
9041 define_sfop3(17,
x / (y * z) ,"
t/(
t*
t)")
9042 define_sfop3(18,
x / (y / z) ,"
t/(
t/
t)")
9043 define_sfop3(19,
x * (y + z) ,"
t*(
t+
t)")
9044 define_sfop3(20,
x * (y - z) ,"
t*(
t-
t)")
9045 define_sfop3(21,
x * (y * z) ,"
t*(
t*
t)")
9046 define_sfop3(22,
x * (y / z) ,"
t*(
t/
t)")
9047 define_sfop3(23,
x - (y + z) ,"
t-(
t+
t)")
9048 define_sfop3(24,
x - (y - z) ,"
t-(
t-
t)")
9049 define_sfop3(25,
x - (y / z) ,"
t-(
t/
t)")
9050 define_sfop3(26,
x - (y * z) ,"
t-(
t*
t)")
9051 define_sfop3(27,
x + (y * z) ,"
t+(
t*
t)")
9052 define_sfop3(28,
x + (y / z) ,"
t+(
t/
t)")
9053 define_sfop3(29,
x + (y + z) ,"
t+(
t+
t)")
9054 define_sfop3(30,
x + (y - z) ,"
t+(
t-
t)")
9055 define_sfop3(31,(
axnb<T,2>(
x,y,z))," ")
9056 define_sfop3(32,(
axnb<T,3>(x,y,z))," ")
9057 define_sfop3(33,(
axnb<T,4>(x,y,z))," ")
9058 define_sfop3(34,(
axnb<T,5>(x,y,z))," ")
9059 define_sfop3(35,(
axnb<T,6>(x,y,z))," ")
9060 define_sfop3(36,(
axnb<T,7>(x,y,z))," ")
9061 define_sfop3(37,(
axnb<T,8>(x,y,z))," ")
9062 define_sfop3(38,(
axnb<T,9>(x,y,z))," ")
9063 define_sfop3(39,x * numeric::log(y) + z,"")
9064 define_sfop3(40,x * numeric::log(y) - z,"")
9065 define_sfop3(41,x * numeric::log10(y) + z,"")
9066 define_sfop3(42,x * numeric::log10(y) - z,"")
9067 define_sfop3(43,x * numeric::sin(y) + z ,"")
9068 define_sfop3(44,x * numeric::sin(y) - z ,"")
9069 define_sfop3(45,x * numeric::cos(y) + z ,"")
9070 define_sfop3(46,x * numeric::cos(y) - z ,"")
9071 define_sfop3(47,details::
is_true(x) ? y : z,"")
9073 #define define_sfop4(NN,OP0,OP1) \
9074 template <typename T> \
9075 struct sf##NN##_op : public sf_base<T> \
9077 typedef typename sf_base<T>::Type Type; \
9078 static inline T process(Type x, Type y, Type z, Type w) \
9082 static inline std::string id() { return OP1; } \
9088 define_sfop4(51,(x + ((y - z) * w)),"
t+((
t-
t)*
t)")
9089 define_sfop4(52,(x + ((y * z) / w)),"
t+((
t*
t)/
t)")
9090 define_sfop4(53,(x + ((y * z) * w)),"
t+((
t*
t)*
t)")
9091 define_sfop4(54,(x + ((y / z) + w)),"
t+((
t/
t)+
t)")
9092 define_sfop4(55,(x + ((y / z) / w)),"
t+((
t/
t)/
t)")
9093 define_sfop4(56,(x + ((y / z) * w)),"
t+((
t/
t)*
t)")
9094 define_sfop4(57,(x - ((y + z) / w)),"
t-((
t+
t)/
t)")
9095 define_sfop4(58,(x - ((y + z) * w)),"
t-((
t+
t)*
t)")
9096 define_sfop4(59,(x - ((y - z) / w)),"
t-((
t-
t)/
t)")
9097 define_sfop4(60,(x - ((y - z) * w)),"
t-((
t-
t)*
t)")
9098 define_sfop4(61,(x - ((y * z) / w)),"
t-((
t*
t)/
t)")
9099 define_sfop4(62,(x - ((y * z) * w)),"
t-((
t*
t)*
t)")
9100 define_sfop4(63,(x - ((y / z) / w)),"
t-((
t/
t)/
t)")
9101 define_sfop4(64,(x - ((y / z) * w)),"
t-((
t/
t)*
t)")
9102 define_sfop4(65,(((x + y) * z) - w),"((
t+
t)*
t)-
t")
9103 define_sfop4(66,(((x - y) * z) - w),"((
t-
t)*
t)-
t")
9104 define_sfop4(67,(((x * y) * z) - w),"((
t*
t)*
t)-
t")
9105 define_sfop4(68,(((x / y) * z) - w),"((
t/
t)*
t)-
t")
9106 define_sfop4(69,(((x + y) / z) - w),"((
t+
t)/
t)-
t")
9107 define_sfop4(70,(((x - y) / z) - w),"((
t-
t)/
t)-
t")
9108 define_sfop4(71,(((x * y) / z) - w),"((
t*
t)/
t)-
t")
9109 define_sfop4(72,(((x / y) / z) - w),"((
t/
t)/
t)-
t")
9110 define_sfop4(73,((x * y) + (z * w)),"(
t*
t)+(
t*
t)")
9111 define_sfop4(74,((x * y) - (z * w)),"(
t*
t)-(
t*
t)")
9112 define_sfop4(75,((x * y) + (z / w)),"(
t*
t)+(
t/
t)")
9113 define_sfop4(76,((x * y) - (z / w)),"(
t*
t)-(
t/
t)")
9114 define_sfop4(77,((x / y) + (z / w)),"(
t/
t)+(
t/
t)")
9115 define_sfop4(78,((x / y) - (z / w)),"(
t/
t)-(
t/
t)")
9116 define_sfop4(79,((x / y) - (z * w)),"(
t/
t)-(
t*
t)")
9117 define_sfop4(80,(x / (y + (z * w))),"
t/(
t+(
t*
t))")
9118 define_sfop4(81,(x / (y - (z * w))),"
t/(
t-(
t*
t))")
9119 define_sfop4(82,(x * (y + (z * w))),"
t*(
t+(
t*
t))")
9120 define_sfop4(83,(x * (y - (z * w))),"
t*(
t-(
t*
t))")
9122 define_sfop4(84,(
axn<T,2>(x,y) +
axn<T,2>(z,w)),"")
9123 define_sfop4(85,(
axn<T,3>(x,y) +
axn<T,3>(z,w)),"")
9124 define_sfop4(86,(
axn<T,4>(x,y) +
axn<T,4>(z,w)),"")
9125 define_sfop4(87,(
axn<T,5>(x,y) +
axn<T,5>(z,w)),"")
9126 define_sfop4(88,(
axn<T,6>(x,y) +
axn<T,6>(z,w)),"")
9127 define_sfop4(89,(
axn<T,7>(x,y) +
axn<T,7>(z,w)),"")
9128 define_sfop4(90,(
axn<T,8>(x,y) +
axn<T,8>(z,w)),"")
9129 define_sfop4(91,(
axn<T,9>(x,y) +
axn<T,9>(z,w)),"")
9130 define_sfop4(92,((details::
is_true(x) && details::
is_true(y)) ? z : w),"")
9131 define_sfop4(93,((details::
is_true(x) || details::
is_true(y)) ? z : w),"")
9132 define_sfop4(94,((x < y) ? z : w),"")
9133 define_sfop4(95,((x <= y) ? z : w),"")
9134 define_sfop4(96,((x > y) ? z : w),"")
9135 define_sfop4(97,((x >= y) ? z : w),"")
9136 define_sfop4(98,(details::
is_true(numeric::
equal(x,y)) ? z : w),"")
9137 define_sfop4(99,(x * numeric::sin(y) + z * numeric::cos(w)),"")
9139 define_sfop4(ext00,((x + y) - (z * w)),"(
t+
t)-(
t*
t)")
9140 define_sfop4(ext01,((x + y) - (z / w)),"(
t+
t)-(
t/
t)")
9141 define_sfop4(ext02,((x + y) + (z * w)),"(
t+
t)+(
t*
t)")
9142 define_sfop4(ext03,((x + y) + (z / w)),"(
t+
t)+(
t/
t)")
9143 define_sfop4(ext04,((x - y) + (z * w)),"(
t-
t)+(
t*
t)")
9144 define_sfop4(ext05,((x - y) + (z / w)),"(
t-
t)+(
t/
t)")
9145 define_sfop4(ext06,((x - y) - (z * w)),"(
t-
t)-(
t*
t)")
9146 define_sfop4(ext07,((x - y) - (z / w)),"(
t-
t)-(
t/
t)")
9147 define_sfop4(ext08,((x + y) - (z - w)),"(
t+
t)-(
t-
t)")
9148 define_sfop4(ext09,((x + y) + (z - w)),"(
t+
t)+(
t-
t)")
9149 define_sfop4(ext10,((x + y) + (z + w)),"(
t+
t)+(
t+
t)")
9150 define_sfop4(ext11,((x + y) * (z - w)),"(
t+
t)*(
t-
t)")
9151 define_sfop4(ext12,((x + y) / (z - w)),"(
t+
t)/(
t-
t)")
9152 define_sfop4(ext13,((x - y) - (z + w)),"(
t-
t)-(
t+
t)")
9153 define_sfop4(ext14,((x - y) + (z + w)),"(
t-
t)+(
t+
t)")
9154 define_sfop4(ext15,((x - y) * (z + w)),"(
t-
t)*(
t+
t)")
9155 define_sfop4(ext16,((x - y) / (z + w)),"(
t-
t)/(
t+
t)")
9156 define_sfop4(ext17,((x * y) - (z + w)),"(
t*
t)-(
t+
t)")
9157 define_sfop4(ext18,((x / y) - (z + w)),"(
t/
t)-(
t+
t)")
9158 define_sfop4(ext19,((x * y) + (z + w)),"(
t*
t)+(
t+
t)")
9159 define_sfop4(ext20,((x / y) + (z + w)),"(
t/
t)+(
t+
t)")
9160 define_sfop4(ext21,((x * y) + (z - w)),"(
t*
t)+(
t-
t)")
9161 define_sfop4(ext22,((x / y) + (z - w)),"(
t/
t)+(
t-
t)")
9162 define_sfop4(ext23,((x * y) - (z - w)),"(
t*
t)-(
t-
t)")
9163 define_sfop4(ext24,((x / y) - (z - w)),"(
t/
t)-(
t-
t)")
9164 define_sfop4(ext25,((x + y) * (z * w)),"(
t+
t)*(
t*
t)")
9165 define_sfop4(ext26,((x + y) * (z / w)),"(
t+
t)*(
t/
t)")
9166 define_sfop4(ext27,((x + y) / (z * w)),"(
t+
t)/(
t*
t)")
9167 define_sfop4(ext28,((x + y) / (z / w)),"(
t+
t)/(
t/
t)")
9168 define_sfop4(ext29,((x - y) / (z * w)),"(
t-
t)/(
t*
t)")
9169 define_sfop4(ext30,((x - y) / (z / w)),"(
t-
t)/(
t/
t)")
9170 define_sfop4(ext31,((x - y) * (z * w)),"(
t-
t)*(
t*
t)")
9171 define_sfop4(ext32,((x - y) * (z / w)),"(
t-
t)*(
t/
t)")
9172 define_sfop4(ext33,((x * y) * (z + w)),"(
t*
t)*(
t+
t)")
9173 define_sfop4(ext34,((x / y) * (z + w)),"(
t/
t)*(
t+
t)")
9174 define_sfop4(ext35,((x * y) / (z + w)),"(
t*
t)/(
t+
t)")
9175 define_sfop4(ext36,((x / y) / (z + w)),"(
t/
t)/(
t+
t)")
9176 define_sfop4(ext37,((x * y) / (z - w)),"(
t*
t)/(
t-
t)")
9177 define_sfop4(ext38,((x / y) / (z - w)),"(
t/
t)/(
t-
t)")
9178 define_sfop4(ext39,((x * y) * (z - w)),"(
t*
t)*(
t-
t)")
9179 define_sfop4(ext40,((x * y) / (z * w)),"(
t*
t)/(
t*
t)")
9180 define_sfop4(ext41,((x / y) * (z / w)),"(
t/
t)*(
t/
t)")
9181 define_sfop4(ext42,((x / y) * (z - w)),"(
t/
t)*(
t-
t)")
9182 define_sfop4(ext43,((x * y) * (z * w)),"(
t*
t)*(
t*
t)")
9183 define_sfop4(ext44,(x + (y * (z / w))),"
t+(
t*(
t/
t))")
9184 define_sfop4(ext45,(x - (y * (z / w))),"
t-(
t*(
t/
t))")
9185 define_sfop4(ext46,(x + (y / (z * w))),"
t+(
t/(
t*
t))")
9186 define_sfop4(ext47,(x - (y / (z * w))),"
t-(
t/(
t*
t))")
9187 define_sfop4(ext48,(((x - y) - z) * w),"((
t-
t)-
t)*
t")
9188 define_sfop4(ext49,(((x - y) - z) / w),"((
t-
t)-
t)/
t")
9189 define_sfop4(ext50,(((x - y) + z) * w),"((
t-
t)+
t)*
t")
9190 define_sfop4(ext51,(((x - y) + z) / w),"((
t-
t)+
t)/
t")
9191 define_sfop4(ext52,((x + (y - z)) * w),"(
t+(
t-
t))*
t")
9192 define_sfop4(ext53,((x + (y - z)) / w),"(
t+(
t-
t))/
t")
9193 define_sfop4(ext54,((x + y) / (z + w)),"(
t+
t)/(
t+
t)")
9194 define_sfop4(ext55,((x - y) / (z - w)),"(
t-
t)/(
t-
t)")
9195 define_sfop4(ext56,((x + y) * (z + w)),"(
t+
t)*(
t+
t)")
9196 define_sfop4(ext57,((x - y) * (z - w)),"(
t-
t)*(
t-
t)")
9197 define_sfop4(ext58,((x - y) + (z - w)),"(
t-
t)+(
t-
t)")
9198 define_sfop4(ext59,((x - y) - (z - w)),"(
t-
t)-(
t-
t)")
9199 define_sfop4(ext60,((x / y) + (z * w)),"(
t/
t)+(
t*
t)")
9200 define_sfop4(ext61,(((x * y) * z) / w),"((
t*
t)*
t)/
t")
9205 template <
typename T,
typename SpecialFunction>
9213 expression_ptr branch0,
9214 expression_ptr branch1,
9215 expression_ptr branch2)
9219 inline T
value()
const
9229 template <
typename T,
typename SpecialFunction>
9255 template <
typename T,
typename SpecialFunction>
9288 template <
typename T,
typename SpecialFunction>
9323 template <
typename T,
typename VarArgFunction>
9330 template <
typename Allocator,
9331 template <
typename,
typename>
class Sequence>
9337 for (std::size_t i = 0; i < arg_list.size(); ++i)
9355 for (std::size_t i = 0; i <
arg_list_.size(); ++i)
9369 return std::numeric_limits<T>::quiet_NaN();
9383 template <
typename T,
typename VarArgFunction>
9390 template <
typename Allocator,
9391 template <
typename,
typename>
class Sequence>
9396 for (std::size_t i = 0; i < arg_list.size(); ++i)
9416 return std::numeric_limits<T>::quiet_NaN();
9429 template <
typename T,
typename VecFunction>
9465 return std::numeric_limits<T>::quiet_NaN();
9480 template <
typename T>
9510 return std::numeric_limits<T>::quiet_NaN();
9518 template <
typename T>
9548 return std::numeric_limits<T>::quiet_NaN();
9556 template <
typename T>
9586 return std::numeric_limits<T>::quiet_NaN();
9594 template <
typename T>
9624 return std::numeric_limits<T>::quiet_NaN();
9632 template <
typename T>
9666 while (vec < upper_bound)
9668 #define exprtk_loop(N) \
9673 #ifndef exprtk_disable_superscalar_unroll
9688 #define case_stmt(N) \
9689 case N : *vec++ = v; \
9691 #ifndef exprtk_disable_superscalar_unroll
9710 return std::numeric_limits<T>::quiet_NaN();
9749 template <
typename T>
9815 while (vec0 < upper_bound)
9817 #define exprtk_loop(N) \
9818 vec0[N] = vec1[N]; \
9822 #ifndef exprtk_disable_superscalar_unroll
9838 #define case_stmt(N) \
9839 case N : *vec0++ = *vec1++; \
9841 #ifndef exprtk_disable_superscalar_unroll
9860 return std::numeric_limits<T>::quiet_NaN();
9902 template <
typename T,
typename Operation>
9931 return std::numeric_limits<T>::quiet_NaN();
9939 template <
typename T,
typename Operation>
9968 return std::numeric_limits<T>::quiet_NaN();
9976 template <
typename T,
typename Operation>
10005 return std::numeric_limits<T>::quiet_NaN();
10013 template <
typename T,
typename Operation>
10042 return std::numeric_limits<T>::quiet_NaN();
10050 template <
typename T,
typename Operation>
10084 while (vec < upper_bound)
10086 #define exprtk_loop(N) \
10087 Operation::assign(vec[N],v); \
10091 #ifndef exprtk_disable_superscalar_unroll
10106 #define case_stmt(N) \
10107 case N : Operation::assign(*vec++,v); \
10109 #ifndef exprtk_disable_superscalar_unroll
10129 return std::numeric_limits<T>::quiet_NaN();
10173 template <
typename T,
typename Operation>
10231 while (vec0 < upper_bound)
10233 #define exprtk_loop(N) \
10234 vec0[N] = Operation::process(vec0[N],vec1[N]); \
10238 #ifndef exprtk_disable_superscalar_unroll
10256 #define case_stmt(N) \
10257 case N : { vec0[i] = Operation::process(vec0[i],vec1[i]); ++i; } \
10259 #ifndef exprtk_disable_superscalar_unroll
10278 return std::numeric_limits<T>::quiet_NaN();
10324 template <
typename T,
typename Operation>
10345 bool v0_is_ivec =
false;
10346 bool v1_is_ivec =
false;
10383 if (v0_is_ivec && (vec0.
size() <= vec1.
size()))
10385 else if (v1_is_ivec && (vec1.
size() <= vec0.
size()))
10417 while (vec2 < upper_bound)
10419 #define exprtk_loop(N) \
10420 vec2[N] = Operation::process(vec0[N],vec1[N]); \
10424 #ifndef exprtk_disable_superscalar_unroll
10443 #define case_stmt(N) \
10444 case N : { vec2[i] = Operation::process(vec0[i],vec1[i]); ++i; } \
10446 #ifndef exprtk_disable_superscalar_unroll
10465 return std::numeric_limits<T>::quiet_NaN();
10508 template <
typename T,
typename Operation>
10527 bool v0_is_ivec =
false;
10575 while (vec0 < upper_bound)
10577 #define exprtk_loop(N) \
10578 vec1[N] = Operation::process(vec0[N],v); \
10582 #ifndef exprtk_disable_superscalar_unroll
10600 #define case_stmt(N) \
10601 case N : { vec1[i] = Operation::process(vec0[i],v); ++i; } \
10603 #ifndef exprtk_disable_superscalar_unroll
10622 return std::numeric_limits<T>::quiet_NaN();
10663 template <
typename T,
typename Operation>
10682 bool v1_is_ivec =
false;
10730 while (vec0 < upper_bound)
10732 #define exprtk_loop(N) \
10733 vec0[N] = Operation::process(v,vec1[N]); \
10737 #ifndef exprtk_disable_superscalar_unroll
10755 #define case_stmt(N) \
10756 case N : { vec0[i] = Operation::process(v,vec1[i]); ++i; } \
10758 #ifndef exprtk_disable_superscalar_unroll
10777 return std::numeric_limits<T>::quiet_NaN();
10818 template <
typename T,
typename Operation>
10835 bool vec0_is_ivec =
false;
10848 vec0_is_ivec =
true;
10882 while (vec0 < upper_bound)
10884 #define exprtk_loop(N) \
10885 vec1[N] = Operation::process(vec0[N]); \
10889 #ifndef exprtk_disable_superscalar_unroll
10907 #define case_stmt(N) \
10908 case N : { vec1[i] = Operation::process(vec0[i]); ++i; } \
10910 #ifndef exprtk_disable_superscalar_unroll
10929 return std::numeric_limits<T>::quiet_NaN();
10970 template <
typename T>
10986 std::not_equal_to<T>()
10988 std::not_equal_to<T>()
10994 template <
typename T>
11010 std::not_equal_to<T>()
11012 std::not_equal_to<T>()
11018 template <
typename T,
typename IFunction, std::
size_t N>
11035 cleanup_branches::execute<T,N>(
branch_);
11038 template <std::
size_t NumBranches>
11043 #pragma warning(push)
11044 #pragma warning(disable: 4127)
11046 if (N != NumBranches)
11050 for (std::size_t i = 0; i < NumBranches; ++i)
11060 #pragma warning(pop)
11064 inline bool operator <(const function_N_node<T,IFunction,N>& fn)
const
11066 return this < (&fn);
11073 #pragma warning(push)
11074 #pragma warning(disable: 4127)
11077 return std::numeric_limits<T>::quiet_NaN();
11085 #pragma warning(pop)
11089 template <
typename T_, std::
size_t BranchCount>
11094 for (std::size_t i = 0; i < BranchCount; ++i)
11096 v[i] = b[i].first->value();
11101 template <
typename T_>
11106 v[0] = b[0].first->value();
11107 v[1] = b[1].first->value();
11108 v[2] = b[2].first->value();
11109 v[3] = b[3].first->value();
11110 v[4] = b[4].first->value();
11114 template <
typename T_>
11119 v[0] = b[0].first->value();
11120 v[1] = b[1].first->value();
11121 v[2] = b[2].first->value();
11122 v[3] = b[3].first->value();
11126 template <
typename T_>
11131 v[0] = b[0].first->value();
11132 v[1] = b[1].first->value();
11133 v[2] = b[2].first->value();
11137 template <
typename T_>
11142 v[0] = b[0].first->value();
11143 v[1] = b[1].first->value();
11147 template <
typename T_>
11152 v[0] = b[0].first->value();
11156 template <
typename T_, std::
size_t ParamCount>
11159 template <
typename T_>
11163 {
return f(
v[0],
v[1],
v[2],
v[3],
v[4],
v[5],
v[6],
v[7],
v[8],
v[9],
v[10],
v[11],
v[12],
v[13],
v[14],
v[15],
v[16],
v[17],
v[18],
v[19]); }
11166 template <
typename T_>
11170 {
return f(
v[0],
v[1],
v[2],
v[3],
v[4],
v[5],
v[6],
v[7],
v[8],
v[9],
v[10],
v[11],
v[12],
v[13],
v[14],
v[15],
v[16],
v[17],
v[18]); }
11173 template <
typename T_>
11177 {
return f(
v[0],
v[1],
v[2],
v[3],
v[4],
v[5],
v[6],
v[7],
v[8],
v[9],
v[10],
v[11],
v[12],
v[13],
v[14],
v[15],
v[16],
v[17]); }
11180 template <
typename T_>
11184 {
return f(
v[0],
v[1],
v[2],
v[3],
v[4],
v[5],
v[6],
v[7],
v[8],
v[9],
v[10],
v[11],
v[12],
v[13],
v[14],
v[15],
v[16]); }
11187 template <
typename T_>
11191 {
return f(
v[0],
v[1],
v[2],
v[3],
v[4],
v[5],
v[6],
v[7],
v[8],
v[9],
v[10],
v[11],
v[12],
v[13],
v[14],
v[15]); }
11194 template <
typename T_>
11198 {
return f(
v[0],
v[1],
v[2],
v[3],
v[4],
v[5],
v[6],
v[7],
v[8],
v[9],
v[10],
v[11],
v[12],
v[13],
v[14]); }
11201 template <
typename T_>
11205 {
return f(
v[0],
v[1],
v[2],
v[3],
v[4],
v[5],
v[6],
v[7],
v[8],
v[9],
v[10],
v[11],
v[12],
v[13]); }
11208 template <
typename T_>
11212 {
return f(
v[0],
v[1],
v[2],
v[3],
v[4],
v[5],
v[6],
v[7],
v[8],
v[9],
v[10],
v[11],
v[12]); }
11215 template <
typename T_>
11219 {
return f(
v[0],
v[1],
v[2],
v[3],
v[4],
v[5],
v[6],
v[7],
v[8],
v[9],
v[10],
v[11]); }
11222 template <
typename T_>
11226 {
return f(
v[0],
v[1],
v[2],
v[3],
v[4],
v[5],
v[6],
v[7],
v[8],
v[9],
v[10]); }
11229 template <
typename T_>
11233 {
return f(
v[0],
v[1],
v[2],
v[3],
v[4],
v[5],
v[6],
v[7],
v[8],
v[9]); }
11236 template <
typename T_>
11240 {
return f(
v[0],
v[1],
v[2],
v[3],
v[4],
v[5],
v[6],
v[7],
v[8]); }
11243 template <
typename T_>
11247 {
return f(
v[0],
v[1],
v[2],
v[3],
v[4],
v[5],
v[6],
v[7]); }
11250 template <
typename T_>
11254 {
return f(
v[0],
v[1],
v[2],
v[3],
v[4],
v[5],
v[6]); }
11257 template <
typename T_>
11261 {
return f(
v[0],
v[1],
v[2],
v[3],
v[4],
v[5]); }
11264 template <
typename T_>
11268 {
return f(
v[0],
v[1],
v[2],
v[3],
v[4]); }
11271 template <
typename T_>
11275 {
return f(
v[0],
v[1],
v[2],
v[3]); }
11278 template <
typename T_>
11282 {
return f(
v[0],
v[1],
v[2]); }
11285 template <
typename T_>
11289 {
return f(
v[0],
v[1]); }
11292 template <
typename T_>
11296 {
return f(
v[0]); }
11311 template <
typename T,
typename IFunction>
11323 inline bool operator <(const function_N_node<T,IFunction,0>& fn)
const
11325 return this < (&fn);
11333 return std::numeric_limits<T>::quiet_NaN();
11346 template <
typename T,
typename VarArgFunction>
11354 const std::vector<expression_ptr>& arg_list)
11358 value_list_.resize(arg_list.size(),std::numeric_limits<T>::quiet_NaN());
11363 for (std::size_t i = 0; i <
arg_list_.size(); ++i)
11372 inline bool operator <(const vararg_function_node<T,VarArgFunction>& fn)
const
11374 return this < (&fn);
11385 return std::numeric_limits<T>::quiet_NaN();
11397 for (std::size_t i = 0; i <
arg_list_.size(); ++i)
11408 template <
typename T,
typename GenericFunction>
11429 GenericFunction* func = (GenericFunction*)(0))
11446 for (std::size_t i = 0; i <
arg_list_.size(); ++i)
11463 #ifndef exprtk_disable_string_capabilities
11482 if (0 == (ri = dynamic_cast<range_interface_t*>(
arg_list_[i])))
11494 range_list_[i].range = reinterpret_cast<range_t*>(0);
11504 if (0 == (var = dynamic_cast<variable_node_ptr_t>(
arg_list_[i])))
11524 inline bool operator <(const generic_function_node<T,GenericFunction>& fn)
const
11526 return this < (&fn);
11535 typedef typename GenericFunction::parameter_list_t parameter_list_t;
11541 return std::numeric_limits<T>::quiet_NaN();
11553 for (std::size_t i = 0; i <
branch_.size(); ++i)
11558 for (std::size_t i = 0; i <
branch_.size(); ++i)
11565 std::size_t r0 = 0;
11566 std::size_t r1 = 0;
11568 if (rp(r0,r1,rdt.
size))
11573 #ifndef exprtk_disable_string_capabilities
11599 #ifndef exprtk_disable_string_capabilities
11600 template <
typename T,
typename StringFunction>
11611 const std::vector<typename gen_function_t::expression_ptr>& arg_list)
11614 range_.
n0_c = std::make_pair<bool,std::size_t>(
true,0);
11615 range_.
n1_c = std::make_pair<bool,std::size_t>(
true,0);
11620 inline bool operator <(const string_function_node<T,StringFunction>& fn)
const
11622 return this < (&fn);
11627 T result = std::numeric_limits<T>::quiet_NaN();
11633 typedef typename StringFunction::parameter_list_t parameter_list_t;
11635 result = (*gen_function_t::function_)(
ret_string_,
11638 range_.
n1_c.second = ret_string_.size() - 1;
11685 template <
typename T,
typename GenericFunction>
11694 const std::size_t& param_seq_index,
11695 const std::vector<typename gen_function_t::expression_ptr>& arg_list)
11702 T result = std::numeric_limits<T>::quiet_NaN();
11708 typedef typename GenericFunction::parameter_list_t parameter_list_t;
11728 #ifndef exprtk_disable_string_capabilities
11729 template <
typename T,
typename StringFunction>
11738 const std::size_t& param_seq_index,
11739 const std::vector<typename str_function_t::expression_ptr>& arg_list)
11746 T result = std::numeric_limits<T>::quiet_NaN();
11752 typedef typename StringFunction::parameter_list_t parameter_list_t;
11782 template <
typename T>
11795 return std::numeric_limits<T>::quiet_NaN();
11799 #ifndef exprtk_disable_return_statement
11800 template <
typename T>
11801 class return_node :
public generic_function_node<T,null_igenfunc<T> >
11810 return_node(
const std::vector<typename gen_function_t::expression_ptr>& arg_list,
11831 return std::numeric_limits<T>::quiet_NaN();
11844 template <
typename T>
11879 return std::numeric_limits<T>::quiet_NaN();
11902 #define exprtk_define_unary_op(OpName) \
11903 template <typename T> \
11904 struct OpName##_op \
11906 typedef typename functor_t<T>::Type Type; \
11907 typedef typename expression_node<T>::node_type node_t; \
11909 static inline T process(Type v) \
11911 return numeric:: OpName (v); \
11914 static inline node_t type() \
11916 return expression_node<T>::e_##OpName; \
11919 static inline details::operator_type operation() \
11921 return details::e_##OpName; \
11965 #undef exprtk_define_unary_op
11967 template <
typename T>
11979 template <
typename T>
11982 typedef typename opr_base<T>::Type
Type;
11991 template <
typename T>
11994 typedef typename opr_base<T>::Type
Type;
12003 template <
typename T>
12006 typedef typename opr_base<T>::Type
Type;
12015 template <
typename T>
12018 typedef typename opr_base<T>::Type
Type;
12027 template <
typename T>
12030 typedef typename opr_base<T>::Type
Type;
12038 template <
typename T>
12041 typedef typename opr_base<T>::Type
Type;
12049 template <
typename T>
12052 typedef typename opr_base<T>::Type
Type;
12054 static inline T
process(
const std::string& t1,
const std::string& t2) {
return ((t1 < t2) ? T(1) : T(0)); }
12059 template <
typename T>
12062 typedef typename opr_base<T>::Type
Type;
12064 static inline T
process(
const std::string& t1,
const std::string& t2) {
return ((t1 <= t2) ? T(1) : T(0)); }
12069 template <
typename T>
12072 typedef typename opr_base<T>::Type
Type;
12074 static inline T
process(
const std::string& t1,
const std::string& t2) {
return ((t1 > t2) ? T(1) : T(0)); }
12079 template <
typename T>
12082 typedef typename opr_base<T>::Type
Type;
12084 static inline T
process(
const std::string& t1,
const std::string& t2) {
return ((t1 >= t2) ? T(1) : T(0)); }
12089 template <
typename T>
12092 typedef typename opr_base<T>::Type
Type;
12093 static inline T
process(
Type t1,
Type t2) {
return (std::equal_to<T>()(t1,t2) ? T(1) : T(0)); }
12094 static inline T
process(
const std::string& t1,
const std::string& t2) {
return ((t1 == t2) ? T(1) : T(0)); }
12099 template <
typename T>
12102 typedef typename opr_base<T>::Type
Type;
12104 static inline T
process(
const std::string& t1,
const std::string& t2) {
return ((t1 == t2) ? T(1) : T(0)); }
12109 template <
typename T>
12112 typedef typename opr_base<T>::Type
Type;
12113 static inline T
process(
Type t1,
Type t2) {
return (std::not_equal_to<T>()(t1,t2) ? T(1) : T(0)); }
12114 static inline T
process(
const std::string& t1,
const std::string& t2) {
return ((t1 != t2) ? T(1) : T(0)); }
12119 template <
typename T>
12122 typedef typename opr_base<T>::Type
Type;
12128 template <
typename T>
12131 typedef typename opr_base<T>::Type
Type;
12137 template <
typename T>
12140 typedef typename opr_base<T>::Type
Type;
12146 template <
typename T>
12149 typedef typename opr_base<T>::Type
Type;
12155 template <
typename T>
12158 typedef typename opr_base<T>::Type
Type;
12164 template <
typename T>
12167 typedef typename opr_base<T>::Type
Type;
12173 template <
typename T>
12176 typedef typename opr_base<T>::Type
Type;
12177 static inline T
process(
const T&,
const T&) {
return std::numeric_limits<T>::quiet_NaN(); }
12178 static inline T
process(
const std::string& t1,
const std::string& t2) {
return ((std::string::npos != t2.find(t1)) ? T(1) : T(0)); }
12183 template <
typename T>
12186 typedef typename opr_base<T>::Type
Type;
12187 static inline T
process(
const T&,
const T&) {
return std::numeric_limits<T>::quiet_NaN(); }
12193 template <
typename T>
12196 typedef typename opr_base<T>::Type
Type;
12197 static inline T
process(
const T&,
const T&) {
return std::numeric_limits<T>::quiet_NaN(); }
12203 template <
typename T>
12206 typedef typename opr_base<T>::Type
Type;
12207 static inline T
process(
const T& t0,
const T& t1,
const T& t2) {
return ((t0 <= t1) && (t1 <= t2)) ? T(1) : T(0); }
12208 static inline T
process(
const std::string& t0,
const std::string& t1,
const std::string& t2)
12210 return ((t0 <= t1) && (t1 <= t2)) ? T(1) : T(0);
12216 template <
typename T>
12222 template <
typename T>
12228 template <
typename T>
12231 typedef typename opr_base<T>::Type
Type;
12233 template <
typename Type,
12234 typename Allocator,
12235 template <
typename,
typename>
class Sequence>
12236 static inline T
process(
const Sequence<Type,Allocator>& arg_list)
12238 switch (arg_list.size())
12240 case 0 :
return T(0);
12250 for (std::size_t i = 0; i < arg_list.size(); ++i)
12252 result +=
value(arg_list[i]);
12260 template <
typename Sequence>
12263 return value(arg_list[0]);
12266 template <
typename Sequence>
12269 return value(arg_list[0]) +
value(arg_list[1]);
12272 template <
typename Sequence>
12275 return value(arg_list[0]) +
value(arg_list[1]) +
12276 value(arg_list[2]) ;
12279 template <
typename Sequence>
12282 return value(arg_list[0]) +
value(arg_list[1]) +
12286 template <
typename Sequence>
12289 return value(arg_list[0]) +
value(arg_list[1]) +
12291 value(arg_list[4]) ;
12295 template <
typename T>
12298 typedef typename opr_base<T>::Type
Type;
12300 template <
typename Type,
12301 typename Allocator,
12302 template <
typename,
typename>
class Sequence>
12303 static inline T
process(
const Sequence<Type,Allocator>& arg_list)
12305 switch (arg_list.size())
12307 case 0 :
return T(0);
12315 T result = T(
value(arg_list[0]));
12317 for (std::size_t i = 1; i < arg_list.size(); ++i)
12319 result *=
value(arg_list[i]);
12327 template <
typename Sequence>
12330 return value(arg_list[0]);
12333 template <
typename Sequence>
12336 return value(arg_list[0]) *
value(arg_list[1]);
12339 template <
typename Sequence>
12342 return value(arg_list[0]) *
value(arg_list[1]) *
12343 value(arg_list[2]) ;
12346 template <
typename Sequence>
12349 return value(arg_list[0]) *
value(arg_list[1]) *
12353 template <
typename Sequence>
12356 return value(arg_list[0]) *
value(arg_list[1]) *
12358 value(arg_list[4]) ;
12362 template <
typename T>
12365 typedef typename opr_base<T>::Type
Type;
12367 template <
typename Type,
12368 typename Allocator,
12369 template <
typename,
typename>
class Sequence>
12370 static inline T
process(
const Sequence<Type,Allocator>& arg_list)
12372 switch (arg_list.size())
12374 case 0 :
return T(0);
12384 template <
typename Sequence>
12387 return value(arg_list[0]);
12390 template <
typename Sequence>
12393 return (
value(arg_list[0]) +
value(arg_list[1])) / T(2);
12396 template <
typename Sequence>
12399 return (
value(arg_list[0]) +
value(arg_list[1]) +
value(arg_list[2])) / T(3);
12402 template <
typename Sequence>
12405 return (
value(arg_list[0]) +
value(arg_list[1]) +
12406 value(arg_list[2]) +
value(arg_list[3])) / T(4);
12409 template <
typename Sequence>
12412 return (
value(arg_list[0]) +
value(arg_list[1]) +
12414 value(arg_list[4])) / T(5);
12418 template <
typename T>
12421 typedef typename opr_base<T>::Type
Type;
12423 template <
typename Type,
12424 typename Allocator,
12425 template <
typename,
typename>
class Sequence>
12426 static inline T
process(
const Sequence<Type,Allocator>& arg_list)
12428 switch (arg_list.size())
12430 case 0 :
return T(0);
12438 T result = T(
value(arg_list[0]));
12440 for (std::size_t i = 1; i < arg_list.size(); ++i)
12442 const T
v =
value(arg_list[i]);
12453 template <
typename Sequence>
12456 return value(arg_list[0]);
12459 template <
typename Sequence>
12462 return std::min<T>(
value(arg_list[0]),
value(arg_list[1]));
12465 template <
typename Sequence>
12468 return std::min<T>(std::min<T>(
value(arg_list[0]),
value(arg_list[1])),
value(arg_list[2]));
12471 template <
typename Sequence>
12474 return std::min<T>(
12475 std::min<T>(
value(arg_list[0]),
value(arg_list[1])),
12476 std::min<T>(
value(arg_list[2]),
value(arg_list[3])));
12479 template <
typename Sequence>
12482 return std::min<T>(
12483 std::min<T>(std::min<T>(
value(arg_list[0]),
value(arg_list[1])),
12484 std::min<T>(
value(arg_list[2]),
value(arg_list[3]))),
12485 value(arg_list[4]));
12489 template <
typename T>
12492 typedef typename opr_base<T>::Type
Type;
12494 template <
typename Type,
12495 typename Allocator,
12496 template <
typename,
typename>
class Sequence>
12497 static inline T
process(
const Sequence<Type,Allocator>& arg_list)
12499 switch (arg_list.size())
12501 case 0 :
return T(0);
12509 T result = T(
value(arg_list[0]));
12511 for (std::size_t i = 1; i < arg_list.size(); ++i)
12513 const T
v =
value(arg_list[i]);
12524 template <
typename Sequence>
12527 return value(arg_list[0]);
12530 template <
typename Sequence>
12533 return std::max<T>(
value(arg_list[0]),
value(arg_list[1]));
12536 template <
typename Sequence>
12539 return std::max<T>(std::max<T>(
value(arg_list[0]),
value(arg_list[1])),
value(arg_list[2]));
12542 template <
typename Sequence>
12545 return std::max<T>(
12546 std::max<T>(
value(arg_list[0]),
value(arg_list[1])),
12547 std::max<T>(
value(arg_list[2]),
value(arg_list[3])));
12550 template <
typename Sequence>
12553 return std::max<T>(
12554 std::max<T>(std::max<T>(
value(arg_list[0]),
value(arg_list[1])),
12555 std::max<T>(
value(arg_list[2]),
value(arg_list[3]))),
12556 value(arg_list[4]));
12560 template <
typename T>
12563 typedef typename opr_base<T>::Type
Type;
12565 template <
typename Type,
12566 typename Allocator,
12567 template <
typename,
typename>
class Sequence>
12568 static inline T
process(
const Sequence<Type,Allocator>& arg_list)
12570 switch (arg_list.size())
12579 for (std::size_t i = 0; i < arg_list.size(); ++i)
12581 if (std::equal_to<T>()(T(0),
value(arg_list[i])))
12590 template <
typename Sequence>
12593 return std::not_equal_to<T>()
12594 (T(0),
value(arg_list[0])) ? T(1) : T(0);
12597 template <
typename Sequence>
12601 std::not_equal_to<T>()(T(0),
value(arg_list[0])) &&
12602 std::not_equal_to<T>()(T(0),
value(arg_list[1]))
12606 template <
typename Sequence>
12610 std::not_equal_to<T>()(T(0),
value(arg_list[0])) &&
12611 std::not_equal_to<T>()(T(0),
value(arg_list[1])) &&
12612 std::not_equal_to<T>()(T(0),
value(arg_list[2]))
12616 template <
typename Sequence>
12620 std::not_equal_to<T>()(T(0),
value(arg_list[0])) &&
12621 std::not_equal_to<T>()(T(0),
value(arg_list[1])) &&
12622 std::not_equal_to<T>()(T(0),
value(arg_list[2])) &&
12623 std::not_equal_to<T>()(T(0),
value(arg_list[3]))
12627 template <
typename Sequence>
12631 std::not_equal_to<T>()(T(0),
value(arg_list[0])) &&
12632 std::not_equal_to<T>()(T(0),
value(arg_list[1])) &&
12633 std::not_equal_to<T>()(T(0),
value(arg_list[2])) &&
12634 std::not_equal_to<T>()(T(0),
value(arg_list[3])) &&
12635 std::not_equal_to<T>()(T(0),
value(arg_list[4]))
12640 template <
typename T>
12643 typedef typename opr_base<T>::Type
Type;
12645 template <
typename Type,
12646 typename Allocator,
12647 template <
typename,
typename>
class Sequence>
12648 static inline T
process(
const Sequence<Type,Allocator>& arg_list)
12650 switch (arg_list.size())
12659 for (std::size_t i = 0; i < arg_list.size(); ++i)
12661 if (std::not_equal_to<T>()(T(0),
value(arg_list[i])))
12670 template <
typename Sequence>
12673 return std::not_equal_to<T>()
12674 (T(0),
value(arg_list[0])) ? T(1) : T(0);
12677 template <
typename Sequence>
12681 std::not_equal_to<T>()(T(0),
value(arg_list[0])) ||
12682 std::not_equal_to<T>()(T(0),
value(arg_list[1]))
12686 template <
typename Sequence>
12690 std::not_equal_to<T>()(T(0),
value(arg_list[0])) ||
12691 std::not_equal_to<T>()(T(0),
value(arg_list[1])) ||
12692 std::not_equal_to<T>()(T(0),
value(arg_list[2]))
12696 template <
typename Sequence>
12700 std::not_equal_to<T>()(T(0),
value(arg_list[0])) ||
12701 std::not_equal_to<T>()(T(0),
value(arg_list[1])) ||
12702 std::not_equal_to<T>()(T(0),
value(arg_list[2])) ||
12703 std::not_equal_to<T>()(T(0),
value(arg_list[3]))
12707 template <
typename Sequence>
12711 std::not_equal_to<T>()(T(0),
value(arg_list[0])) ||
12712 std::not_equal_to<T>()(T(0),
value(arg_list[1])) ||
12713 std::not_equal_to<T>()(T(0),
value(arg_list[2])) ||
12714 std::not_equal_to<T>()(T(0),
value(arg_list[3])) ||
12715 std::not_equal_to<T>()(T(0),
value(arg_list[4]))
12720 template <
typename T>
12723 typedef typename opr_base<T>::Type
Type;
12725 template <
typename Type,
12726 typename Allocator,
12727 template <
typename,
typename>
class Sequence>
12728 static inline T
process(
const Sequence<Type,Allocator>& arg_list)
12730 switch (arg_list.size())
12732 case 0 :
return std::numeric_limits<T>::quiet_NaN();
12743 for (std::size_t i = 0; i < (arg_list.size() - 1); ++i)
12745 value(arg_list[i]);
12748 return value(arg_list.back());
12753 template <
typename Sequence>
12756 return value(arg_list[0]);
12759 template <
typename Sequence>
12762 value(arg_list[0]);
12763 return value(arg_list[1]);
12766 template <
typename Sequence>
12769 value(arg_list[0]);
12770 value(arg_list[1]);
12771 return value(arg_list[2]);
12774 template <
typename Sequence>
12777 value(arg_list[0]);
12778 value(arg_list[1]);
12779 value(arg_list[2]);
12780 return value(arg_list[3]);
12783 template <
typename Sequence>
12786 value(arg_list[0]);
12787 value(arg_list[1]);
12788 value(arg_list[2]);
12789 value(arg_list[3]);
12790 return value(arg_list[4]);
12793 template <
typename Sequence>
12796 value(arg_list[0]);
12797 value(arg_list[1]);
12798 value(arg_list[2]);
12799 value(arg_list[3]);
12800 value(arg_list[4]);
12801 return value(arg_list[5]);
12804 template <
typename Sequence>
12807 value(arg_list[0]);
12808 value(arg_list[1]);
12809 value(arg_list[2]);
12810 value(arg_list[3]);
12811 value(arg_list[4]);
12812 value(arg_list[5]);
12813 return value(arg_list[6]);
12816 template <
typename Sequence>
12819 value(arg_list[0]);
12820 value(arg_list[1]);
12821 value(arg_list[2]);
12822 value(arg_list[3]);
12823 value(arg_list[4]);
12824 value(arg_list[5]);
12825 value(arg_list[6]);
12826 return value(arg_list[7]);
12830 template <
typename T>
12838 const std::size_t vec_size = v->
vec()->
vds().
size();
12842 if (vec_size <= static_cast<std::size_t>(lud.
batch_size))
12850 #define case_stmt(N) \
12851 case N : result += vec[i++]; \
12853 #ifndef exprtk_disable_superscalar_unroll
12872 T(0), T(0), T(0), T(0), T(0), T(0), T(0), T(0),
12873 T(0), T(0), T(0), T(0), T(0), T(0), T(0), T(0)
12878 while (vec < upper_bound)
12880 #define exprtk_loop(N) \
12885 #ifndef exprtk_disable_superscalar_unroll
12902 #define case_stmt(N) \
12903 case N : r[0] += vec[i++]; \
12905 #ifndef exprtk_disable_superscalar_unroll
12921 return (r[ 0] + r[ 1] + r[ 2] + r[ 3])
12922 #ifndef exprtk_disable_superscalar_unroll
12923 + (r[ 4] + r[ 5] + r[ 6] + r[ 7])
12924 + (r[ 8] + r[ 9] + r[10] + r[11])
12925 + (r[12] + r[13] + r[14] + r[15])
12931 template <
typename T>
12939 const std::size_t vec_size = v->
vec()->
vds().
size();
12943 if (vec_size <= static_cast<std::size_t>(lud.
batch_size))
12951 #define case_stmt(N) \
12952 case N : result *= vec[i++]; \
12954 #ifndef exprtk_disable_superscalar_unroll
12973 T(1), T(1), T(1), T(1), T(1), T(1), T(1), T(1),
12974 T(1), T(1), T(1), T(1), T(1), T(1), T(1), T(1)
12979 while (vec < upper_bound)
12981 #define exprtk_loop(N) \
12986 #ifndef exprtk_disable_superscalar_unroll
13003 #define case_stmt(N) \
13004 case N : r[0] *= vec[i++]; \
13006 #ifndef exprtk_disable_superscalar_unroll
13022 return (r[ 0] * r[ 1] * r[ 2] * r[ 3])
13023 #ifndef exprtk_disable_superscalar_unroll
13024 + (r[ 4] * r[ 5] * r[ 6] * r[ 7])
13025 + (r[ 8] * r[ 9] * r[10] * r[11])
13026 + (r[12] * r[13] * r[14] * r[15])
13032 template <
typename T>
13039 const std::size_t vec_size = v->
vec()->
vds().
size();
13045 template <
typename T>
13053 const std::size_t vec_size = v->
vec()->
vds().
size();
13057 for (std::size_t i = 1; i < vec_size; ++i)
13069 template <
typename T>
13077 const std::size_t vec_size = v->
vec()->
vds().
size();
13081 for (std::size_t i = 1; i < vec_size; ++i)
13093 template <
typename T>
13106 virtual const T&
v0()
const = 0;
13108 virtual const T&
v1()
const = 0;
13111 template <
typename T>
13124 virtual const T
c()
const = 0;
13126 virtual const T&
v()
const = 0;
13129 template <
typename T>
13142 virtual const T
c()
const = 0;
13144 virtual const T&
v()
const = 0;
13147 template <
typename T>
13155 virtual const T&
v()
const = 0;
13158 template <
typename T>
13166 virtual const T&
v()
const = 0;
13169 template <
typename T>
13182 virtual const T
c()
const = 0;
13184 virtual void set_c(
const T) = 0;
13189 template <
typename T>
13202 virtual const T
c()
const = 0;
13204 virtual void set_c(
const T) = 0;
13209 template <
typename T>
13222 virtual const T&
v()
const = 0;
13225 template <
typename T>
13239 template <
typename T>
13253 template <
typename T>
13261 virtual std::string
type_id()
const = 0;
13264 template <
typename T>
13272 virtual std::string
type_id()
const = 0;
13275 template <
typename T,
typename Operation>
13294 return Operation::type();
13299 return Operation::operation();
13302 inline const T&
v()
const
13315 template <
typename T>
13388 template <
typename T,
typename Operation>
13416 return Operation::type();
13421 return Operation::operation();
13448 template <
typename T>
struct is_ref<T&> {
enum {result = 1}; };
13449 template <
typename T>
struct is_ref<const T&> {
enum {result = 0}; };
13451 template <std::
size_t State>
13457 #define exprtk_crtype(Type) \
13458 param_to_str<is_const_ref< Type >::result>::result() \
13460 template <
typename T>
13471 return bf1(bf0(t0,t1),t2);
13474 template <
typename T0,
typename T1,
typename T2>
13475 static inline std::string
id()
13489 return bf0(t0,bf1(t1,t2));
13492 template <
typename T0,
typename T1,
typename T2>
13493 static inline std::string
id()
13503 template <
typename T>
13512 const T& t2,
const T& t3,
13516 return bf1(bf0(t0,t1),bf2(t2,t3));
13519 template <
typename T0,
typename T1,
typename T2,
typename T3>
13520 static inline std::string
id()
13533 const T& t2,
const T& t3,
13537 return bf0(t0,bf1(t1,bf2(t2,t3)));
13539 template <
typename T0,
typename T1,
typename T2,
typename T3>
13540 static inline std::string
id()
13553 const T& t2,
const T& t3,
13557 return bf0(t0,bf2(bf1(t1,t2),t3));
13560 template <
typename T0,
typename T1,
typename T2,
typename T3>
13561 static inline std::string
id()
13574 const T& t2,
const T& t3,
13578 return bf2(bf1(bf0(t0,t1),t2),t3);
13581 template <
typename T0,
typename T1,
typename T2,
typename T3>
13582 static inline std::string
id()
13595 const T& t2,
const T& t3,
13599 return bf2(bf0(t0,bf1(t1,t2)),t3);
13602 template <
typename T0,
typename T1,
typename T2,
typename T3>
13603 static inline std::string
id()
13614 #undef exprtk_crtype
13616 template <
typename T,
typename T0,
typename T1>
13618 template <
typename T,
typename T0,
typename T1>
13621 #define synthesis_node_type_define(T0_,T1_,v_) \
13622 template <typename T, typename T0, typename T1> \
13623 struct nodetype_T0oT1<T,T0_,T1_> { static const typename expression_node<T>::node_type result; }; \
13624 template <typename T, typename T0, typename T1> \
13625 const typename expression_node<T>::node_type nodetype_T0oT1<T,T0_,T1_>::result = expression_node<T>:: v_; \
13636 #undef synthesis_node_type_define
13638 template <
typename T,
typename T0,
typename T1,
typename T2>
13640 template <
typename T,
typename T0,
typename T1,
typename T2>
13643 #define synthesis_node_type_define(T0_,T1_,T2_,v_) \
13644 template <typename T, typename T0, typename T1, typename T2> \
13645 struct nodetype_T0oT1oT2<T,T0_,T1_,T2_> { static const typename expression_node<T>::node_type result; }; \
13646 template <typename T, typename T0, typename T1, typename T2> \
13647 const typename expression_node<T>::node_type nodetype_T0oT1oT2<T,T0_,T1_,T2_>::result = expression_node<T>:: v_; \
13658 #undef synthesis_node_type_define
13660 template <
typename T,
typename T0,
typename T1,
typename T2,
typename T3>
13662 template <
typename T,
typename T0,
typename T1,
typename T2,
typename T3>
13665 #define synthesis_node_type_define(T0_,T1_,T2_,T3_,v_) \
13666 template <typename T, typename T0, typename T1, typename T2, typename T3> \
13667 struct nodetype_T0oT1oT2oT3<T,T0_,T1_,T2_,T3_> { static const typename expression_node<T>::node_type result; }; \
13668 template <typename T, typename T0, typename T1, typename T2, typename T3> \
13669 const typename expression_node<T>::node_type nodetype_T0oT1oT2oT3<T,T0_,T1_,T2_,T3_>::result = expression_node<T>:: v_; \
13687 #undef synthesis_node_type_define
13689 template <
typename T,
typename T0,
typename T1>
13736 template <
typename Allocator>
13742 .template allocate_type<node_type,T0,T1,bfunc_t&>
13756 template <
typename T,
typename T0,
typename T1,
typename T2,
typename ProcessMode>
13821 static inline std::string
id()
13823 return process_mode_t::template id<T0,T1,T2>();
13826 template <
typename Allocator>
13830 .template allocate_type<node_type,T0,T1,T2,bfunc_t,bfunc_t>
13831 (p0, p1, p2, p3, p4);
13846 template <
typename T,
typename T0_,
typename T1_,
typename T2_,
typename T3_,
typename ProcessMode>
13916 static inline std::string
id()
13918 return process_mode_t::template id<T0,T1,T2,T3>();
13921 template <
typename Allocator>
13923 T0 p0, T1 p1, T2 p2, T3 p3,
13927 .template allocate_type<node_type,T0,T1,T2,T3,bfunc_t,bfunc_t>
13928 (p0, p1, p2, p3, p4, p5, p6);
13945 template <
typename T,
typename T0,
typename T1,
typename T2>
14003 static inline std::string
id()
14008 template <
typename Allocator>
14012 .template allocate_type<node_type,T0,T1,T2,tfunc_t>
14027 template <
typename T,
typename T0,
typename T1,
typename T2>
14035 virtual T0
t0()
const = 0;
14037 virtual T1
t1()
const = 0;
14039 virtual T2
t2()
const = 0;
14042 template <
typename T,
typename T0,
typename T1,
typename T2,
typename SF3Operation>
14094 static inline std::string
id()
14096 return SF3Operation::id();
14099 template <
typename Allocator>
14103 .template allocate_type<node_type,T0,T1,T2>
14117 template <
typename T>
14127 default :
return false;
14131 template <
typename T,
typename T0,
typename T1,
typename T2,
typename T3>
14195 static inline std::string
id()
14200 template <
typename Allocator>
14204 .template allocate_type<node_type,T0,T1,T2,T3,qfunc_t>
14205 (p0, p1, p2, p3, p4);
14220 template <
typename T,
typename T0,
typename T1,
typename T2,
typename T3,
typename SF4Operation>
14278 static inline std::string
id()
14280 return SF4Operation::id();
14283 template <
typename Allocator>
14287 .template allocate_type<node_type,T0,T1,T2,T3>
14302 template <
typename T>
14316 default :
return false;
14320 template <
typename T,
typename T0,
typename T1>
14326 template <
typename T,
typename T0,
typename T1,
typename T2>
14335 template <
typename T,
typename T0,
typename T1,
typename T2,
typename T3>
14346 template <
typename T,
typename Operation>
14367 return Operation::type();
14372 return Operation::operation();
14396 template <
typename T,
typename Operation>
14417 return Operation::type();
14422 return Operation::operation();
14425 inline const T
c()
const
14430 inline const T&
v()
const
14446 template <
typename T,
typename Operation>
14467 return Operation::operation();
14470 inline const T
c()
const
14475 inline const T&
v()
const
14491 template <
typename T,
typename Operation>
14504 init_branches<1>(
branch_,brnch);
14509 cleanup_branches::execute<T,1>(
branch_);
14519 return Operation::operation();
14522 inline const T&
v()
const
14541 template <
typename T,
typename Operation>
14554 init_branches<1>(
branch_,brnch);
14559 cleanup_branches::execute<T,1>(
branch_);
14569 return Operation::operation();
14572 inline const T&
v()
const
14591 template <
typename T,
typename Operation>
14604 init_branches<1>(
branch_,brnch);
14609 cleanup_branches::execute<T,1>(
branch_);
14619 return Operation::operation();
14622 inline const T
c()
const
14629 (*
const_cast<T*
>(&
c_)) = new_c;
14652 template <
typename T,
typename Operation>
14665 init_branches<1>(
branch_,brnch);
14670 cleanup_branches::execute<T,1>(
branch_);
14680 return Operation::operation();
14683 inline const T
c()
const
14690 (*
const_cast<T*
>(&
c_)) = new_c;
14713 #ifndef exprtk_disable_string_capabilities
14714 template <
typename T,
typename SType0,
typename SType1,
typename Operation>
14735 return Operation::type();
14740 return Operation::operation();
14764 template <
typename T,
typename SType0,
typename SType1,
typename RangePack,
typename Operation>
14786 std::size_t r0 = 0;
14787 std::size_t r1 = 0;
14789 if (
rp0_(r0, r1,
s0_.size()))
14797 return Operation::type();
14802 return Operation::operation();
14827 template <
typename T,
typename SType0,
typename SType1,
typename RangePack,
typename Operation>
14849 std::size_t r0 = 0;
14850 std::size_t r1 = 0;
14852 if (
rp1_(r0, r1,
s1_.size()))
14860 return Operation::type();
14865 return Operation::operation();
14890 template <
typename T,
typename SType0,
typename SType1,
typename RangePack,
typename Operation>
14914 std::size_t r0_0 = 0;
14915 std::size_t r0_1 = 0;
14916 std::size_t r1_0 = 0;
14917 std::size_t r1_1 = 0;
14920 rp0_(r0_0, r1_0,
s0_.size()) &&
14925 s0_.substr(r0_0, (r1_0 - r0_0) + 1),
14926 s1_.substr(r0_1, (r1_1 - r0_1) + 1)
14935 return Operation::type();
14940 return Operation::operation();
14966 template <
typename T,
typename Operation>
15030 std::size_t str0_r0 = 0;
15031 std::size_t str0_r1 = 0;
15033 std::size_t str1_r0 = 0;
15034 std::size_t str1_r1 = 0;
15036 range_t& range0 = (*str0_range_ptr_);
15037 range_t& range1 = (*str1_range_ptr_);
15051 return std::numeric_limits<T>::quiet_NaN();
15056 return Operation::type();
15061 return Operation::operation();
15075 template <
typename T,
typename SType0,
typename SType1,
typename SType2,
typename Operation>
15097 return Operation::type();
15102 return Operation::operation();
15133 template <
typename T,
typename PowOp>
15147 return PowOp::result(
v_);
15163 template <
typename T,
typename PowOp>
15174 init_branches<1>(
branch_, brnch);
15179 cleanup_branches::execute<T,1>(
branch_);
15184 return PowOp::result(
branch_[0].first->value());
15200 template <
typename T,
typename PowOp>
15214 return (T(1) / PowOp::result(
v_));
15230 template <
typename T,
typename PowOp>
15241 init_branches<1>(
branch_, brnch);
15246 cleanup_branches::execute<T,1>(
branch_);
15251 return (T(1) / PowOp::result(
branch_[0].first->value()));
15267 template <
typename T>
15273 template <
typename T>
15279 template <
typename T>
15285 template <
typename T>
15291 template <
typename T>
15297 template <
typename T>
15303 template <
typename T>
15309 template <
typename T>
15315 template <
typename T>
15321 template <
typename T>
15327 template <
typename T>
15333 template <
typename T>
15339 template <
typename T>
15345 template <
typename T>
15351 template <
typename T>
15357 template <
typename T>
15363 template <
typename T>
15369 template <
typename T>
15375 template <
typename T>
15381 template <
typename T>
15386 switch (node->
type())
15399 default :
return false;
15406 class node_allocator
15410 template <
typename ResultNode,
typename OpType,
typename ExprNode>
15413 return allocate<ResultNode>(operation,branch[0]);
15416 template <
typename ResultNode,
typename OpType,
typename ExprNode>
15419 return allocate<ResultNode>(operation,branch[0],branch[1]);
15422 template <
typename ResultNode,
typename OpType,
typename ExprNode>
15425 return allocate<ResultNode>(operation,branch[0],branch[1],branch[2]);
15428 template <
typename ResultNode,
typename OpType,
typename ExprNode>
15431 return allocate<ResultNode>(operation,branch[0],branch[1],branch[2],branch[3]);
15434 template <
typename ResultNode,
typename OpType,
typename ExprNode>
15437 return allocate<ResultNode>(operation,branch[0],branch[1],branch[2],branch[3],branch[4]);
15440 template <
typename ResultNode,
typename OpType,
typename ExprNode>
15443 return allocate<ResultNode>(operation,branch[0],branch[1],branch[2],branch[3],branch[4],branch[5]);
15446 template <
typename node_type>
15449 return (
new node_type());
15452 template <
typename node_type,
15454 typename Allocator,
15455 template <
typename,
typename>
class Sequence>
15458 return (
new node_type(seq));
15461 template <
typename node_type,
typename T1>
15464 return (
new node_type(t1));
15467 template <
typename node_type,
typename T1>
15470 return (
new node_type(t1));
15473 template <
typename node_type,
15474 typename T1,
typename T2>
15477 return (
new node_type(t1, t2));
15480 template <
typename node_type,
15481 typename T1,
typename T2>
15484 return (
new node_type(t1, t2));
15487 template <
typename node_type,
15488 typename T1,
typename T2>
15491 return (
new node_type(t1, t2));
15494 template <
typename node_type,
15495 typename T1,
typename T2>
15498 return (
new node_type(t1, t2));
15501 template <
typename node_type,
15502 typename T1,
typename T2>
15505 return (
new node_type(t1, t2));
15508 template <
typename node_type,
15509 typename T1,
typename T2,
typename T3>
15512 return (
new node_type(t1, t2, t3));
15515 template <
typename node_type,
15516 typename T1,
typename T2,
typename T3,
typename T4>
15519 return (
new node_type(t1, t2, t3, t4));
15522 template <
typename node_type,
15523 typename T1,
typename T2,
typename T3>
15526 return (
new node_type(t1, t2, t3));
15529 template <
typename node_type,
15530 typename T1,
typename T2,
typename T3,
typename T4>
15533 return (
new node_type(t1, t2, t3, t4));
15536 template <
typename node_type,
15537 typename T1,
typename T2,
typename T3,
typename T4,
typename T5>
15540 return (
new node_type(t1, t2, t3, t4, t5));
15543 template <
typename node_type,
15544 typename T1,
typename T2,
typename T3>
15546 const T3& t3)
const
15548 return (
new node_type(t1, t2, t3));
15551 template <
typename node_type,
15552 typename T1,
typename T2,
15553 typename T3,
typename T4>
15555 const T3& t3,
const T4& t4)
const
15557 return (
new node_type(t1, t2, t3, t4));
15560 template <
typename node_type,
15561 typename T1,
typename T2,
15562 typename T3,
typename T4,
typename T5>
15564 const T3& t3,
const T4& t4,
15565 const T5& t5)
const
15567 return (
new node_type(t1, t2, t3, t4, t5));
15570 template <
typename node_type,
15571 typename T1,
typename T2,
15572 typename T3,
typename T4,
typename T5,
typename T6>
15574 const T3& t3,
const T4& t4,
15575 const T5& t5,
const T6& t6)
const
15577 return (
new node_type(t1, t2, t3, t4, t5, t6));
15580 template <
typename node_type,
15581 typename T1,
typename T2,
15582 typename T3,
typename T4,
15583 typename T5,
typename T6,
typename T7>
15585 const T3& t3,
const T4& t4,
15586 const T5& t5,
const T6& t6,
15587 const T7& t7)
const
15589 return (
new node_type(t1, t2, t3, t4, t5, t6, t7));
15592 template <
typename node_type,
15593 typename T1,
typename T2,
15594 typename T3,
typename T4,
15595 typename T5,
typename T6,
15596 typename T7,
typename T8>
15598 const T3& t3,
const T4& t4,
15599 const T5& t5,
const T6& t6,
15600 const T7& t7,
const T8& t8)
const
15602 return (
new node_type(t1, t2, t3, t4, t5, t6, t7, t8));
15605 template <
typename node_type,
15606 typename T1,
typename T2,
15607 typename T3,
typename T4,
15608 typename T5,
typename T6,
15609 typename T7,
typename T8,
typename T9>
15611 const T3& t3,
const T4& t4,
15612 const T5& t5,
const T6& t6,
15613 const T7& t7,
const T8& t8,
15614 const T9& t9)
const
15616 return (
new node_type(t1, t2, t3, t4, t5, t6, t7, t8, t9));
15619 template <
typename node_type,
15620 typename T1,
typename T2,
15621 typename T3,
typename T4,
15622 typename T5,
typename T6,
15623 typename T7,
typename T8,
15624 typename T9,
typename T10>
15626 const T3& t3,
const T4& t4,
15627 const T5& t5,
const T6& t6,
15628 const T7& t7,
const T8& t8,
15629 const T9& t9,
const T10& t10)
const
15631 return (
new node_type(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10));
15634 template <
typename node_type,
15635 typename T1,
typename T2,
typename T3>
15638 return (
new node_type(t1, t2, t3));
15641 template <
typename node_type,
15642 typename T1,
typename T2,
15643 typename T3,
typename T4>
15645 T3 t3, T4 t4)
const
15647 return (
new node_type(t1, t2, t3, t4));
15650 template <
typename node_type,
15651 typename T1,
typename T2,
15652 typename T3,
typename T4,
15658 return (
new node_type(t1, t2, t3, t4, t5));
15661 template <
typename node_type,
15662 typename T1,
typename T2,
15663 typename T3,
typename T4,
15664 typename T5,
typename T6>
15667 T5 t5, T6 t6)
const
15669 return (
new node_type(t1, t2, t3, t4, t5, t6));
15672 template <
typename node_type,
15673 typename T1,
typename T2,
15674 typename T3,
typename T4,
15675 typename T5,
typename T6,
typename T7>
15681 return (
new node_type(t1, t2, t3, t4, t5, t6, t7));
15684 template <
typename T>
15694 #define register_op(Symbol,Type,Args) \
15695 m.insert(std::make_pair(std::string(Symbol),details::base_operation_t(Type,Args))); \
15793 template <
typename FunctionType>
15796 func.allow_zero_parameters() =
true;
15798 if (0 != func.min_num_args())
15800 func.min_num_args() = 0;
15804 template <
typename FunctionType>
15807 func.allow_zero_parameters() =
false;
15810 template <
typename FunctionType>
15813 func.has_side_effects() =
true;
15816 template <
typename FunctionType>
15819 func.has_side_effects() =
false;
15822 template <
typename FunctionType>
15825 func.min_num_args() = num_args;
15827 if ((0 != func.min_num_args()) && func.allow_zero_parameters())
15828 func.allow_zero_parameters() =
false;
15831 template <
typename FunctionType>
15834 func.max_num_args() = num_args;
15837 template <
typename T>
15849 #define empty_method_body \
15851 return std::numeric_limits<T>::quiet_NaN(); \
15857 inline virtual T operator() (const T&)
15860 inline virtual T operator() (const T&,const T&)
15863 inline virtual T operator() (const T&, const T&, const T&)
15866 inline virtual T operator() (const T&, const T&, const T&, const T&)
15869 inline virtual T operator() (const T&, const T&, const T&, const T&, const T&)
15872 inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&)
15875 inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&)
15878 inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&)
15881 inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&)
15884 inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&)
15887 inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&,
15891 inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&,
15892 const T&, const T&)
15895 inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&,
15896 const T&, const T&, const T&)
15899 inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&,
15900 const T&, const T&, const T&, const T&)
15903 inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&,
15904 const T&, const T&, const T&, const T&, const T&)
15907 inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&,
15908 const T&, const T&, const T&, const T&, const T&, const T&)
15911 inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&,
15912 const T&, const T&, const T&, const T&, const T&, const T&, const T&)
15915 inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&,
15916 const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&)
15919 inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&,
15920 const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&)
15923 inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&,
15924 const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&)
15927 #undef empty_method_body
15932 template <
typename T>
15942 exprtk_debug((
"ivararg_function::operator() - Operator has not been overridden.\n"));
15943 return std::numeric_limits<T>::quiet_NaN();
15947 template <
typename T>
15963 : parameter_sequence(param_seq),
15970 #define igeneric_function_empty_body(N) \
15972 exprtk_debug(("igeneric_function::operator() - Operator has not been overridden. ["#N"]\n")); \
15973 return std::numeric_limits<T>::quiet_NaN(); \
15989 inline virtual T operator() (const std::
size_t&, std::
string&,
parameter_list_t)
15992 std::
string parameter_sequence;
15999 template <typename T>
16004 typedef T (*ff00_functor)();
16005 typedef T (*ff01_functor)(T);
16006 typedef T (*ff02_functor)(T,T);
16007 typedef T (*ff03_functor)(T,T,T);
16008 typedef T (*ff04_functor)(T,T,T,T);
16009 typedef T (*ff05_functor)(T,T,T,T,T);
16010 typedef T (*ff06_functor)(T,T,T,T,T,T);
16011 typedef T (*ff07_functor)(T,T,T,T,T,T,T);
16012 typedef T (*ff08_functor)(T,T,T,T,T,T,T,T);
16013 typedef T (*ff09_functor)(T,T,T,T,T,T,T,T,T);
16014 typedef T (*ff10_functor)(T,T,T,T,T,T,T,T,T,T);
16015 typedef T (*ff11_functor)(T,T,T,T,T,T,T,T,T,T,T);
16016 typedef T (*ff12_functor)(T,T,T,T,T,T,T,T,T,T,T,T);
16017 typedef T (*ff13_functor)(T,T,T,T,T,T,T,T,T,T,T,T,T);
16018 typedef T (*ff14_functor)(T,T,T,T,T,T,T,T,T,T,T,T,T,T);
16019 typedef T (*ff15_functor)(T,T,T,T,T,T,T,T,T,T,T,T,T,T,T);
16028 inline T operator() ()
16038 inline T operator() (
const T& v0)
16048 inline T operator() (
const T& v0,
const T& v1)
16049 {
return f(v0, v1); }
16058 inline T operator() (
const T& v0,
const T& v1,
const T& v2)
16059 {
return f(v0, v1, v2); }
16068 inline T operator() (
const T& v0,
const T& v1,
const T& v2,
const T& v3)
16069 {
return f(v0, v1, v2, v3); }
16078 inline T operator() (
const T& v0,
const T& v1,
const T& v2,
const T& v3,
const T& v4)
16079 {
return f(v0, v1, v2, v3, v4); }
16088 inline T operator() (
const T& v0,
const T& v1,
const T& v2,
const T& v3,
const T& v4,
const T& v5)
16089 {
return f(v0, v1, v2, v3, v4, v5); }
16098 inline T operator() (
const T& v0,
const T& v1,
const T& v2,
const T& v3,
const T& v4,
16099 const T& v5,
const T& v6)
16100 {
return f(v0, v1, v2, v3, v4, v5, v6); }
16109 inline T operator() (
const T& v0,
const T& v1,
const T& v2,
const T& v3,
const T& v4,
16110 const T& v5,
const T& v6,
const T& v7)
16111 {
return f(v0, v1, v2, v3, v4, v5, v6, v7); }
16120 inline T operator() (
const T& v0,
const T& v1,
const T& v2,
const T& v3,
const T& v4,
16121 const T& v5,
const T& v6,
const T& v7,
const T& v8)
16122 {
return f(v0, v1, v2, v3, v4, v5, v6, v7, v8); }
16131 inline T operator() (
const T& v0,
const T& v1,
const T& v2,
const T& v3,
const T& v4,
16132 const T& v5,
const T& v6,
const T& v7,
const T& v8,
const T& v9)
16133 {
return f(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9); }
16142 inline T operator() (
const T& v0,
const T& v1,
const T& v2,
const T& v3,
const T& v4,
16143 const T& v5,
const T& v6,
const T& v7,
const T& v8,
const T& v9,
const T& v10)
16144 {
return f(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10); }
16153 inline T operator() (
const T& v00,
const T& v01,
const T& v02,
const T& v03,
const T& v04,
16154 const T& v05,
const T& v06,
const T& v07,
const T& v08,
const T& v09,
16155 const T& v10,
const T& v11)
16156 {
return f(v00, v01, v02, v03, v04, v05, v06, v07, v08, v09, v10, v11); }
16165 inline T operator() (
const T& v00,
const T& v01,
const T& v02,
const T& v03,
const T& v04,
16166 const T& v05,
const T& v06,
const T& v07,
const T& v08,
const T& v09,
16167 const T& v10,
const T& v11,
const T& v12)
16168 {
return f(v00, v01, v02, v03, v04, v05, v06, v07, v08, v09, v10, v11, v12); }
16177 inline T operator() (
const T& v00,
const T& v01,
const T& v02,
const T& v03,
const T& v04,
16178 const T& v05,
const T& v06,
const T& v07,
const T& v08,
const T& v09,
16179 const T& v10,
const T& v11,
const T& v12,
const T& v13)
16180 {
return f(v00, v01, v02, v03, v04, v05, v06, v07, v08, v09, v10, v11, v12, v13); }
16189 inline T operator() (
const T& v00,
const T& v01,
const T& v02,
const T& v03,
const T& v04,
16190 const T& v05,
const T& v06,
const T& v07,
const T& v08,
const T& v09,
16191 const T& v10,
const T& v11,
const T& v12,
const T& v13,
const T& v14)
16192 {
return f(v00, v01, v02, v03, v04, v05, v06, v07, v08, v09, v10, v11, v12, v13, v14); }
16196 template <
typename Type,
typename RawType>
16205 #ifndef exprtk_disable_string_capabilities
16212 typedef std::map<std::string,type_pair_t,details::ilesscompare>
type_map_t;
16216 enum { lut_size = 256 };
16227 if (symbol_name.empty())
16229 else if (map.end() != map.find(symbol_name))
16235 template <
typename PtrType>
16239 return std::string();
16243 while (map.end() != itr)
16245 if (itr->second.second == ptr)
16253 return std::string();
16258 if (symbol_name.empty())
16264 if (map.end() == itr)
16267 return (*itr).second.first;
16271 template <
typename Tie,
typename RType>
16272 inline bool add_impl(
const std::string& symbol_name, RType
t,
const bool is_const)
16274 if (symbol_name.size() > 1)
16285 const tm_itr_t itr = map.find(symbol_name);
16287 if (map.end() == itr)
16289 map[symbol_name] = Tie::make(t,is_const);
16298 static inline std::pair<bool,vector_t*>
make(std::pair<T*,std::size_t>
v,
const bool is_const =
false)
16300 return std::make_pair(is_const,
new vector_t(v.first, v.second));
16306 template <
typename Allocator>
16307 static inline std::pair<bool,vector_t*>
make(std::vector<T,Allocator>&
v,
const bool is_const =
false)
16309 return std::make_pair(is_const,
new vector_t(v));
16317 return std::make_pair(is_const,
new vector_t(v));
16323 template <
typename Allocator>
16324 static inline std::pair<bool,vector_t*>
make(std::deque<T,Allocator>&
v,
const bool is_const =
false)
16326 return std::make_pair(is_const,
new vector_t(v));
16330 template <std::
size_t v_size>
16331 inline bool add(
const std::string& symbol_name, T (&
v)[v_size],
const bool is_const =
false)
16333 return add_impl<tie_array,std::pair<T*,std::size_t> >
16334 (symbol_name, std::make_pair(
v,v_size), is_const);
16337 inline bool add(
const std::string& symbol_name, T*
v,
const std::size_t v_size,
const bool is_const =
false)
16339 return add_impl<tie_array,std::pair<T*,std::size_t> >
16340 (symbol_name, std::make_pair(v,v_size), is_const);
16343 template <
typename Allocator>
16344 inline bool add(
const std::string& symbol_name, std::vector<T,Allocator>&
v,
const bool is_const =
false)
16346 return add_impl<tie_stdvec,std::vector<T,Allocator>&>
16347 (symbol_name,
v, is_const);
16352 return add_impl<tie_vecview,exprtk::vector_view<T>&>
16353 (symbol_name,
v, is_const);
16356 template <
typename Allocator>
16357 inline bool add(
const std::string& symbol_name, std::deque<T,Allocator>&
v,
const bool is_const =
false)
16359 return add_impl<tie_stddeq,std::deque<T,Allocator>&>
16360 (symbol_name,
v, is_const);
16363 inline bool add(
const std::string& symbol_name, RawType&
t,
const bool is_const =
false)
16367 static inline std::pair<bool,variable_node_t*> make(T& t,
const bool is_const =
false)
16372 #ifndef exprtk_disable_string_capabilities
16373 static inline std::pair<bool,stringvar_node_t*> make(std::string& t,
const bool is_const =
false)
16379 static inline std::pair<bool,function_t*> make(
function_t& t,
const bool is_constant =
false)
16381 return std::make_pair(is_constant,&t);
16384 static inline std::pair<bool,vararg_function_t*> make(
vararg_function_t& t,
const bool is_const =
false)
16386 return std::make_pair(is_const,&t);
16389 static inline std::pair<bool,generic_function_t*> make(
generic_function_t& t,
const bool is_constant =
false)
16391 return std::make_pair(is_constant,&t);
16395 const tm_itr_t itr = map.find(symbol_name);
16397 if (map.end() == itr)
16399 map[symbol_name] = tie::make(t,is_const);
16410 if (map.end() == itr)
16411 return reinterpret_cast<type_ptr>(0);
16413 return itr->second.second;
16416 template <
typename TType,
typename TRawType,
typename PtrType>
16419 static inline bool test(
const PtrType,
const void*)
16425 template <
typename TType,
typename TRawType>
16430 exprtk_debug((
"ptr_match::test() - %p <--> %p\n",(
void*)(&(p->
ref())),ptr));
16431 return (&(p->
ref()) == ptr);
16439 while (map.end() != itr)
16441 type_ptr ret_ptr = itr->second.second;
16443 if (ptr_match<Type,RawType,type_ptr>::test(ret_ptr,ptr))
16454 inline bool remove(
const std::string& symbol_name,
const bool delete_node =
true)
16456 const tm_itr_t itr = map.find(symbol_name);
16458 if (map.end() != itr)
16462 static inline void process(std::pair<bool,variable_node_t*>& n) {
delete n.second; }
16463 static inline void process(std::pair<bool,vector_t*>& n) {
delete n.second; }
16464 #ifndef exprtk_disable_string_capabilities
16465 static inline void process(std::pair<bool,stringvar_node_t*>& n) {
delete n.second; }
16467 static inline void process(std::pair<bool,function_t*>&) { }
16488 static inline double set(
double) {
return (0.0); }
16489 static inline double set(
long double) {
return (0.0); }
16490 static inline float set(
float) {
return (0.0f); }
16491 static inline std::string set(std::string) {
return std::string(
""); }
16494 static RawType null_type = init_type::set(RawType());
16498 if (map.end() == itr)
16501 return itr->second.second->ref();
16504 inline void clear(
const bool delete_node =
true)
16508 static inline void process(std::pair<bool,variable_node_t*>& n) {
delete n.second; }
16509 static inline void process(std::pair<bool,vector_t*>& n) {
delete n.second; }
16510 static inline void process(std::pair<bool,function_t*>&) { }
16511 #ifndef exprtk_disable_string_capabilities
16512 static inline void process(std::pair<bool,stringvar_node_t*>& n) {
delete n.second; }
16536 template <
typename Allocator,
16537 template <
typename,
typename>
class Sequence>
16538 inline std::size_t
get_list(Sequence<std::pair<std::string,RawType>,Allocator>& list)
const
16540 std::size_t count = 0;
16549 list.push_back(std::make_pair((*itr).first,itr->second.second->ref()));
16558 template <
typename Allocator,
16559 template <
typename,
typename>
class Sequence>
16560 inline std::size_t
get_list(Sequence<std::string,Allocator>& vlist)
const
16562 std::size_t count = 0;
16571 vlist.push_back((*itr).first);
16585 #ifndef exprtk_disable_string_capabilities
16596 static const std::size_t lut_size = 256;
16604 #ifndef exprtk_disable_string_capabilities
16628 for (std::size_t i = 0; i < free_function_list_.size(); ++i)
16630 delete free_function_list_[i];
16636 return (reserved_symbol_table_.end() != reserved_symbol_table_.find(symbol));
16647 sd =
reinterpret_cast<st_data*
>(0);
16668 if (data_ && (0 == ref_count))
16670 st_data::destroy(data_);
16679 template <
typename SymTab>
16713 control_block::destroy(control_block_,
this);
16719 control_block_->ref_count++;
16726 control_block::destroy(control_block_,
reinterpret_cast<symbol_table<T>*
>(0));
16729 control_block_->ref_count++;
16742 local_data().variable_store.clear(delete_node);
16747 local_data().function_store.clear();
16752 #ifndef exprtk_disable_string_capabilities
16753 local_data().stringvar_store.clear();
16759 local_data().vector_store.clear();
16764 local_data().local_symbol_list_.clear();
16769 if (!valid())
return;
16770 clear_variables ();
16771 clear_functions ();
16774 clear_local_constants();
16780 return local_data().variable_store.size;
16785 #ifndef exprtk_disable_string_capabilities
16789 return local_data().stringvar_store.size;
16798 return local_data().function_store.size;
16806 return local_data().vector_store.size;
16814 return reinterpret_cast<variable_ptr
>(0);
16815 else if (!valid_symbol(variable_name))
16816 return reinterpret_cast<variable_ptr>(0);
16818 return local_data().variable_store.get(variable_name);
16824 return reinterpret_cast<variable_ptr
>(0);
16826 return local_data().variable_store.get_from_varptr(
16827 reinterpret_cast<const void*>(&var_ref));
16830 #ifndef exprtk_disable_string_capabilities
16834 return reinterpret_cast<stringvar_ptr
>(0);
16835 else if (!valid_symbol(string_name))
16836 return reinterpret_cast<stringvar_ptr>(0);
16838 return local_data().stringvar_store.get(string_name);
16845 return reinterpret_cast<function_ptr
>(0);
16846 else if (!valid_symbol(function_name))
16847 return reinterpret_cast<function_ptr>(0);
16849 return local_data().function_store.get(function_name);
16855 return reinterpret_cast<vararg_function_ptr
>(0);
16856 else if (!valid_symbol(vararg_function_name))
16857 return reinterpret_cast<vararg_function_ptr>(0);
16859 return local_data().vararg_function_store.get(vararg_function_name);
16865 return reinterpret_cast<generic_function_ptr
>(0);
16866 else if (!valid_symbol(function_name))
16867 return reinterpret_cast<generic_function_ptr>(0);
16869 return local_data().generic_function_store.get(function_name);
16875 return reinterpret_cast<generic_function_ptr
>(0);
16876 else if (!valid_symbol(function_name))
16877 return reinterpret_cast<generic_function_ptr>(0);
16879 return local_data().string_function_store.get(function_name);
16884 inline vector_holder_ptr
get_vector(
const std::string& vector_name)
const
16887 return reinterpret_cast<vector_holder_ptr
>(0);
16888 else if (!valid_symbol(vector_name))
16889 return reinterpret_cast<vector_holder_ptr>(0);
16891 return local_data().vector_store.get(vector_name);
16896 static T null_var = T(0);
16899 else if (!valid_symbol(symbol_name))
16902 return local_data().variable_store.type_ref(symbol_name);
16905 #ifndef exprtk_disable_string_capabilities
16908 static std::string null_stringvar;
16910 return null_stringvar;
16911 else if (!valid_symbol(symbol_name))
16912 return null_stringvar;
16914 return local_data().stringvar_store.type_ref(symbol_name);
16922 else if (!valid_symbol(symbol_name))
16925 return local_data().variable_store.is_constant(symbol_name);
16928 #ifndef exprtk_disable_string_capabilities
16933 else if (!valid_symbol(symbol_name))
16935 else if (!local_data().stringvar_store.symbol_exists(symbol_name))
16938 return local_data().stringvar_store.is_constant(symbol_name);
16946 else if (!valid_symbol(variable_name))
16948 else if (symbol_exists(variable_name))
16951 local_data().local_symbol_list_.push_back(
value);
16952 T&
t = local_data().local_symbol_list_.back();
16954 return add_variable(variable_name,t);
16957 #ifndef exprtk_disable_string_capabilities
16962 else if (!valid_symbol(stringvar_name))
16964 else if (symbol_exists(stringvar_name))
16967 local_data().local_stringvar_list_.push_back(
value);
16968 std::string& s = local_data().local_stringvar_list_.back();
16970 return add_stringvar(stringvar_name,s);
16974 inline bool add_variable(
const std::string& variable_name, T&
t,
const bool is_constant =
false)
16978 else if (!valid_symbol(variable_name))
16980 else if (symbol_exists(variable_name))
16983 return local_data().variable_store.add(variable_name,t,is_constant);
16990 else if (!valid_symbol(constant_name))
16992 else if (symbol_exists(constant_name))
16995 local_data().local_symbol_list_.push_back(value);
16996 T&
t = local_data().local_symbol_list_.back();
16998 return add_variable(constant_name,t,
true);
17001 #ifndef exprtk_disable_string_capabilities
17002 inline bool add_stringvar(
const std::string& stringvar_name, std::string& s,
const bool is_constant =
false)
17006 else if (!valid_symbol(stringvar_name))
17008 else if (symbol_exists(stringvar_name))
17011 return local_data().stringvar_store.add(stringvar_name,s,is_constant);
17015 inline bool add_function(
const std::string& function_name, function_t&
function)
17019 else if (!valid_symbol(function_name))
17021 else if (symbol_exists(function_name))
17024 return local_data().function_store.add(function_name,
function);
17027 inline bool add_function(
const std::string& vararg_function_name, vararg_function_t& vararg_function)
17031 else if (!valid_symbol(vararg_function_name))
17033 else if (symbol_exists(vararg_function_name))
17036 return local_data().vararg_function_store.add(vararg_function_name,vararg_function);
17039 inline bool add_function(
const std::string& function_name, generic_function_t&
function)
17043 else if (!valid_symbol(function_name))
17045 else if (symbol_exists(function_name))
17047 else if (std::string::npos !=
function.parameter_sequence.find_first_not_of(
"STVZ*?|"))
17049 else if (generic_function_t::e_rtrn_scalar ==
function.rtrn_type)
17050 return local_data().generic_function_store.add(function_name,
function);
17051 else if (generic_function_t::e_rtrn_string ==
function.rtrn_type)
17052 return local_data().string_function_store.add(function_name,
function);
17057 #define exprtk_define_freefunction(NN) \
17058 inline bool add_function(const std::string& function_name, ff##NN##_functor function) \
17061 { return false; } \
17062 if (!valid_symbol(function_name)) \
17063 { return false; } \
17064 if (symbol_exists(function_name)) \
17065 { return false; } \
17067 exprtk::ifunction<T>* ifunc = new freefunc##NN(function); \
17069 local_data().free_function_list_.push_back(ifunc); \
17071 return add_function(function_name,(*local_data().free_function_list_.back())); \
17083 #undef exprtk_define_freefunction
17085 inline bool add_reserved_function(
const std::string& function_name, function_t&
function)
17089 else if (!valid_symbol(function_name,
false))
17091 else if (symbol_exists(function_name,
false))
17094 return local_data().function_store.add(function_name,
function);
17101 else if (!valid_symbol(vararg_function_name,
false))
17103 else if (symbol_exists(vararg_function_name,
false))
17106 return local_data().vararg_function_store.add(vararg_function_name,vararg_function);
17113 else if (!valid_symbol(function_name,
false))
17115 else if (symbol_exists(function_name,
false))
17117 else if (std::string::npos !=
function.parameter_sequence.find_first_not_of(
"STV*?|"))
17119 else if (generic_function_t::e_rtrn_scalar ==
function.rtrn_type)
17120 return local_data().generic_function_store.add(function_name,
function);
17121 else if (generic_function_t::e_rtrn_string ==
function.rtrn_type)
17122 return local_data().string_function_store.add(function_name,
function);
17127 template <std::
size_t N>
17132 else if (!valid_symbol(vector_name))
17134 else if (symbol_exists(vector_name))
17137 return local_data().vector_store.add(vector_name,
v);
17140 inline bool add_vector(
const std::string& vector_name, T*
v,
const std::size_t& v_size)
17144 else if (!valid_symbol(vector_name))
17146 else if (symbol_exists(vector_name))
17148 else if (0 == v_size)
17151 return local_data().vector_store.add(vector_name,v,v_size);
17154 template <
typename Allocator>
17155 inline bool add_vector(
const std::string& vector_name, std::vector<T,Allocator>&
v)
17159 else if (!valid_symbol(vector_name))
17161 else if (symbol_exists(vector_name))
17163 else if (0 == v.size())
17166 return local_data().vector_store.add(vector_name,v);
17173 else if (!valid_symbol(vector_name))
17175 else if (symbol_exists(vector_name))
17177 else if (0 == v.
size())
17180 return local_data().vector_store.add(vector_name,v);
17188 return local_data().variable_store.remove(variable_name, delete_node);
17191 #ifndef exprtk_disable_string_capabilities
17197 return local_data().stringvar_store.remove(string_name);
17206 return local_data().function_store.remove(function_name);
17214 return local_data().vararg_function_store.remove(vararg_function_name);
17222 return local_data().vector_store.remove(vector_name);
17227 return add_pi () &&
17235 static const T local_pi = details::numeric::details::const_pi_impl<T>(num_type);
17236 return add_constant(
"pi",local_pi);
17242 return add_constant(
"epsilon",local_epsilon);
17247 static const T local_infinity = std::numeric_limits<T>::infinity();
17248 return add_constant(
"inf",local_infinity);
17251 template <
typename Package>
17254 return package.register_package(*
this);
17257 template <
typename Allocator,
17258 template <
typename,
typename>
class Sequence>
17264 return local_data().variable_store.get_list(vlist);
17267 template <
typename Allocator,
17268 template <
typename,
typename>
class Sequence>
17274 return local_data().variable_store.get_list(vlist);
17277 #ifndef exprtk_disable_string_capabilities
17278 template <
typename Allocator,
17279 template <
typename,
typename>
class Sequence>
17285 return local_data().stringvar_store.get_list(svlist);
17288 template <
typename Allocator,
17289 template <
typename,
typename>
class Sequence>
17295 return local_data().stringvar_store.get_list(svlist);
17299 template <
typename Allocator,
17300 template <
typename,
typename>
class Sequence>
17306 return local_data().vector_store.get_list(vlist);
17309 inline bool symbol_exists(
const std::string& symbol_name,
const bool check_reserved_symb =
true)
const
17318 else if (local_data().variable_store.symbol_exists(symbol_name))
17320 #ifndef exprtk_disable_string_capabilities
17321 else if (local_data().stringvar_store.symbol_exists(symbol_name))
17324 else if (local_data().vector_store.symbol_exists(symbol_name))
17326 else if (local_data().function_store.symbol_exists(symbol_name))
17328 else if (check_reserved_symb && local_data().is_reserved_symbol(symbol_name))
17339 return local_data().variable_store.symbol_exists(variable_name);
17342 #ifndef exprtk_disable_string_capabilities
17348 return local_data().stringvar_store.symbol_exists(stringvar_name);
17355 else if (!valid_symbol(symbol_name))
17357 else if (!local_data().stringvar_store.symbol_exists(symbol_name))
17361 local_data().stringvar_store.symbol_exists(symbol_name) ||
17362 local_data().stringvar_store.is_constant (symbol_name)
17372 return local_data().function_store.symbol_exists(function_name);
17380 return local_data().vararg_function_store.symbol_exists(vararg_function_name);
17388 return local_data().vector_store.symbol_exists(vector_name);
17393 return local_data().variable_store.entity_name(ptr);
17398 return local_data().vector_store.entity_name(ptr);
17401 #ifndef exprtk_disable_string_capabilities
17404 return local_data().stringvar_store.entity_name(ptr);
17409 return local_data().stringvar_store.entity_name(ptr);
17416 return control_block_ && control_block_->data_;
17422 std::vector<std::string> name_list;
17424 st.
local_data().function_store.get_list(name_list);
17426 if (!name_list.empty())
17428 for (std::size_t i = 0; i < name_list.size(); ++i)
17431 add_function(name_list[i],ifunc);
17437 std::vector<std::string> name_list;
17439 st.
local_data().vararg_function_store.get_list(name_list);
17441 if (!name_list.empty())
17443 for (std::size_t i = 0; i < name_list.size(); ++i)
17446 add_function(name_list[i],ivafunc);
17452 std::vector<std::string> name_list;
17454 st.
local_data().generic_function_store.get_list(name_list);
17456 if (!name_list.empty())
17458 for (std::size_t i = 0; i < name_list.size(); ++i)
17461 add_function(name_list[i],ifunc);
17467 std::vector<std::string> name_list;
17469 st.
local_data().string_function_store.get_list(name_list);
17471 if (!name_list.empty())
17473 for (std::size_t i = 0; i < name_list.size(); ++i)
17476 add_function(name_list[i],ifunc);
17484 inline bool valid_symbol(
const std::string& symbol,
const bool check_reserved_symb =
true)
const
17486 if (symbol.empty())
17490 else if (symbol.size() > 1)
17492 for (std::size_t i = 1; i < symbol.size(); ++i)
17499 if ((
'.' == symbol[i]) && (i < (symbol.size() - 1)))
17507 return (check_reserved_symb) ? (!local_data().is_reserved_symbol(symbol)) :
true;
17512 if (symbol.empty())
17516 else if (symbol.size() > 1)
17518 for (std::size_t i = 1; i < symbol.size(); ++i)
17525 if ((
'.' == symbol[i]) && (i < (symbol.size() - 1)))
17540 return *(control_block_->data_);
17545 return *(control_block_->data_);
17550 friend class parser<T>;
17553 template <
typename T>
17556 template <
typename T>
17603 retinv_null(false),
17604 return_invoked(&retinv_null)
17611 retinv_null(false),
17612 return_invoked(&retinv_null)
17622 if (!local_data_list.empty())
17624 for (std::size_t i = 0; i < local_data_list.size(); ++i)
17626 switch (local_data_list[i].
type)
17628 case e_expr :
delete reinterpret_cast<expression_ptr
>(local_data_list[i].pointer);
17631 case e_vecholder :
delete reinterpret_cast<vector_holder_ptr
>(local_data_list[i].pointer);
17634 case e_data :
delete (T*)(local_data_list[i].pointer);
17637 case e_vecdata :
delete [] (T*)(local_data_list[i].pointer);
17640 case e_string :
delete (std::string*)(local_data_list[i].pointer);
17688 : control_block_(0)
17694 : control_block_ (e.control_block_ ),
17695 symbol_table_list_(e.symbol_table_list_)
17697 control_block_->ref_count++;
17701 : control_block_(0)
17704 symbol_table_list_.push_back(symbol_table);
17711 if (control_block_)
17714 (0 != control_block_->ref_count) &&
17715 (0 == --control_block_->ref_count)
17718 delete control_block_;
17721 control_block_ = 0;
17725 control_block_->ref_count++;
17734 return (
this == &e);
17740 (0 == control_block_ ) ||
17741 (0 == control_block_->expr)
17747 control_block::destroy(control_block_);
17754 control_block::destroy(control_block_);
17759 return control_block_->expr->value();
17762 inline T operator() ()
const
17767 inline operator T()
const
17772 inline operator bool()
const
17779 symbol_table_list_.push_back(st);
17784 return symbol_table_list_[index];
17789 return symbol_table_list_[index];
17796 if (control_block_->results)
17797 return (*control_block_->results);
17801 return null_results;
17807 return (*control_block_->return_invoked);
17814 return symbol_table_list_;
17821 if (control_block_)
17823 if (0 == --control_block_->ref_count)
17825 delete control_block_;
17829 control_block_ = control_block::create(expr);
17837 if (control_block_)
17840 local_data_list.push_back(
17842 data_pack(reinterpret_cast<void*>(expr),
17843 control_block::e_expr));
17852 if (control_block_)
17855 local_data_list.push_back(
17857 data_pack(reinterpret_cast<void*>(vec_holder),
17858 control_block::e_vecholder));
17867 if (control_block_)
17873 case 0 : dt = control_block::e_data;
break;
17874 case 1 : dt = control_block::e_vecdata;
break;
17875 case 2 : dt = control_block::e_string;
break;
17879 local_data_list.push_back(
17881 data_pack(reinterpret_cast<void*>(data), dt, size));
17888 if (control_block_)
17890 return control_block_->local_data_list;
17895 return null_local_data_list;
17901 if (control_block_ && rc)
17903 control_block_->results = rc;
17909 if (control_block_)
17911 control_block_->return_invoked = retinvk_ptr;
17918 friend class parser<T>;
17919 friend class expression_helper<T>;
17923 template <
typename T>
17924 class expression_helper
17959 template <
typename T>
17965 namespace parser_error
17996 const std::string& diagnostic =
"",
17997 const std::string& src_location =
"")
18010 const std::string& diagnostic =
"",
18011 const std::string& src_location =
"")
18026 case e_unknown :
return std::string(
"Unknown Error");
18027 case e_syntax :
return std::string(
"Syntax Error" );
18028 case e_token :
return std::string(
"Token Error" );
18029 case e_numeric :
return std::string(
"Numeric Error");
18030 case e_symtab :
return std::string(
"Symbol Error" );
18031 case e_lexer :
return std::string(
"Lexer Error" );
18032 case e_helper :
return std::string(
"Helper Error" );
18033 default :
return std::string(
"Unknown Error");
18040 expression.empty() ||
18048 std::size_t error_line_start = 0;
18054 if ((
'\n' == c) || (
'\r' == c))
18056 error_line_start = i + 1;
18061 std::size_t next_nl_position =
std::min(expression.size(),
18065 error.
error_line = expression.substr(error_line_start,
18066 next_nl_position - error_line_start);
18070 for (std::size_t i = 0; i < next_nl_position; ++i)
18072 if (
'\n' == expression[i])
18081 printf(
"Position: %02d Type: [%s] Msg: %s\n",
18090 template <
typename Parser>
18093 p.state_.type_check_enabled =
false;
18097 template <
typename T>
18098 class parser :
public lexer::parser_helper
18140 #ifndef exprtk_disable_break_continue
18152 #ifndef exprtk_disable_string_capabilities
18191 typedef std::map<std::string,std::pair<trinary_functor_t ,operator_t> >
sf3_map_t;
18192 typedef std::map<std::string,std::pair<quaternary_functor_t,operator_t> >
sf4_map_t;
18195 typedef std::multimap<std::string,details::base_operation_t,details::ilesscompare>
base_ops_map_t;
18240 #ifndef exprtk_disable_string_capabilities
18246 size (std::numeric_limits<std::size_t>::
max()),
18247 index(std::numeric_limits<std::size_t>::
max()),
18248 depth(std::numeric_limits<std::size_t>::
max()),
18256 #ifndef exprtk_disable_string_capabilities
18267 else if (depth < se.
depth)
18269 else if (depth > se.
depth)
18271 else if (index < se.
index)
18273 else if (index > se.
index)
18292 #ifndef exprtk_disable_string_capabilities
18308 #ifndef exprtk_disable_string_capabilities
18323 input_param_cnt_(0)
18328 return element_.size();
18333 return element_.empty();
18338 if (index < element_.size())
18339 return element_[index];
18341 return null_element_;
18347 const std::size_t current_depth = parser_.state_.scope_depth;
18349 for (std::size_t i = 0; i < element_.size(); ++i)
18353 if (se.
depth > current_depth)
18357 (se.
index == index)
18362 return null_element_;
18368 const std::size_t current_depth = parser_.state_.scope_depth;
18370 for (std::size_t i = 0; i < element_.size(); ++i)
18374 if (se.
depth > current_depth)
18378 (se.
index == index) &&
18384 return null_element_;
18389 for (std::size_t i = 0; i < element_.size(); ++i)
18404 element_.push_back(se);
18405 std::sort(element_.begin(),element_.end());
18413 static_cast<int>(parser_.state_.scope_depth)));
18415 for (std::size_t i = 0; i < element_.size(); ++i)
18422 static_cast<int>(i),
18434 case scope_element::e_variable :
if (se.
data )
delete (T*) se.
data;
18438 case scope_element::e_vector :
if (se.
data )
delete[] (T*) se.
data;
18445 #ifndef exprtk_disable_string_capabilities
18446 case scope_element::e_string :
if (se.
data )
delete (std::string*) se.
data;
18459 for (std::size_t i = 0; i < element_.size(); ++i)
18461 free_element(element_[i]);
18466 input_param_cnt_ = 0;
18471 return ++input_param_cnt_;
18476 for (std::size_t i = 0; i < element_.size(); ++i)
18488 if (&(vn->
ref()) == (&v))
18517 parser_.state_.scope_depth++;
18518 #ifdef exprtk_enable_debugging
18519 std::string depth(2 * parser_.state_.scope_depth,
'-');
18522 static_cast<int>(parser_.state_.scope_depth)));
18528 parser_.sem_.deactivate(parser_.state_.scope_depth);
18529 parser_.state_.scope_depth--;
18530 #ifdef exprtk_enable_debugging
18531 std::string depth(2 * parser_.state_.scope_depth,
'-');
18534 static_cast<int>(parser_.state_.scope_depth)));
18552 #ifndef exprtk_disable_string_capabilities
18561 return symtab_list_.empty();
18566 symtab_list_.clear();
18573 for (std::size_t i = 0; i < symtab_list_.size(); ++i)
18575 if (symtab_list_[i].valid())
18585 if (!symtab_list_.empty())
18586 return symtab_list_[0].valid_symbol(symbol);
18593 if (!symtab_list_.empty())
18594 return symtab_list_[0].valid_function(symbol);
18601 if (!valid_symbol(variable_name))
18602 return reinterpret_cast<variable_ptr
>(0);
18604 variable_ptr result =
reinterpret_cast<variable_ptr
>(0);
18606 for (std::size_t i = 0; i < symtab_list_.size(); ++i)
18608 if (!symtab_list_[i].valid())
18611 result = local_data(i)
18612 .variable_store.get(variable_name);
18622 variable_ptr result =
reinterpret_cast<variable_ptr
>(0);
18624 for (std::size_t i = 0; i < symtab_list_.size(); ++i)
18626 if (!symtab_list_[i].valid())
18629 result = local_data(i).variable_store
18630 .get_from_varptr(reinterpret_cast<const void*>(&var_ref));
18638 #ifndef exprtk_disable_string_capabilities
18641 if (!valid_symbol(string_name))
18642 return reinterpret_cast<stringvar_ptr
>(0);
18644 stringvar_ptr result =
reinterpret_cast<stringvar_ptr
>(0);
18646 for (std::size_t i = 0; i < symtab_list_.size(); ++i)
18648 if (!symtab_list_[i].valid())
18651 result = local_data(i)
18652 .stringvar_store.get(string_name);
18663 if (!valid_function_name(function_name))
18664 return reinterpret_cast<function_ptr
>(0);
18666 function_ptr result =
reinterpret_cast<function_ptr
>(0);
18668 for (std::size_t i = 0; i < symtab_list_.size(); ++i)
18670 if (!symtab_list_[i].valid())
18673 result = local_data(i)
18674 .function_store.get(function_name);
18684 if (!valid_function_name(vararg_function_name))
18685 return reinterpret_cast<vararg_function_ptr
>(0);
18687 vararg_function_ptr result =
reinterpret_cast<vararg_function_ptr
>(0);
18689 for (std::size_t i = 0; i < symtab_list_.size(); ++i)
18691 if (!symtab_list_[i].valid())
18694 result = local_data(i)
18695 .vararg_function_store.get(vararg_function_name);
18705 if (!valid_function_name(function_name))
18706 return reinterpret_cast<generic_function_ptr
>(0);
18708 generic_function_ptr result =
reinterpret_cast<generic_function_ptr
>(0);
18710 for (std::size_t i = 0; i < symtab_list_.size(); ++i)
18712 if (!symtab_list_[i].valid())
18715 result = local_data(i)
18716 .generic_function_store.get(function_name);
18726 if (!valid_function_name(function_name))
18727 return reinterpret_cast<generic_function_ptr
>(0);
18729 generic_function_ptr result =
reinterpret_cast<generic_function_ptr
>(0);
18731 for (std::size_t i = 0; i < symtab_list_.size(); ++i)
18733 if (!symtab_list_[i].valid())
18737 local_data(i).string_function_store.get(function_name);
18745 inline vector_holder_ptr
get_vector(
const std::string& vector_name)
const
18747 if (!valid_symbol(vector_name))
18748 return reinterpret_cast<vector_holder_ptr
>(0);
18750 vector_holder_ptr result =
reinterpret_cast<vector_holder_ptr
>(0);
18752 for (std::size_t i = 0; i < symtab_list_.size(); ++i)
18754 if (!symtab_list_[i].valid())
18758 local_data(i).vector_store.get(vector_name);
18768 if (!valid_symbol(symbol_name))
18771 for (std::size_t i = 0; i < symtab_list_.size(); ++i)
18773 if (!symtab_list_[i].valid())
18775 else if (local_data(i).variable_store.is_constant(symbol_name))
18782 #ifndef exprtk_disable_string_capabilities
18785 if (!valid_symbol(symbol_name))
18788 for (std::size_t i = 0; i < symtab_list_.size(); ++i)
18790 if (!symtab_list_[i].valid())
18792 else if (!local_data(i).stringvar_store.symbol_exists(symbol_name))
18794 else if ( local_data(i).stringvar_store.is_constant(symbol_name))
18804 for (std::size_t i = 0; i < symtab_list_.size(); ++i)
18806 if (!symtab_list_[i].valid())
18808 else if (symtab_list_[i].symbol_exists(symbol))
18817 for (std::size_t i = 0; i < symtab_list_.size(); ++i)
18819 if (!symtab_list_[i].valid())
18822 symtab_list_[i].local_data().variable_store
18823 .symbol_exists(variable_name)
18831 #ifndef exprtk_disable_string_capabilities
18834 for (std::size_t i = 0; i < symtab_list_.size(); ++i)
18836 if (!symtab_list_[i].valid())
18839 symtab_list_[i].local_data().stringvar_store
18840 .symbol_exists(stringvar_name)
18850 for (std::size_t i = 0; i < symtab_list_.size(); ++i)
18852 if (!symtab_list_[i].valid())
18855 symtab_list_[i].local_data().stringvar_store
18856 .symbol_exists(symbol_name)
18860 local_data(i).stringvar_store.symbol_exists(symbol_name) ||
18861 local_data(i).stringvar_store.is_constant (symbol_name)
18873 for (std::size_t i = 0; i < symtab_list_.size(); ++i)
18875 if (!symtab_list_[i].valid())
18878 local_data(i).vararg_function_store
18879 .symbol_exists(function_name)
18889 for (std::size_t i = 0; i < symtab_list_.size(); ++i)
18891 if (!symtab_list_[i].valid())
18894 local_data(i).vararg_function_store
18895 .symbol_exists(vararg_function_name)
18905 for (std::size_t i = 0; i < symtab_list_.size(); ++i)
18907 if (!symtab_list_[i].valid())
18910 local_data(i).vector_store
18911 .symbol_exists(vector_name)
18921 return local_data().variable_store.entity_name(ptr);
18926 return local_data().vector_store.entity_name(ptr);
18929 #ifndef exprtk_disable_string_capabilities
18932 return local_data().stringvar_store.entity_name(ptr);
18937 return local_data().stringvar_store.entity_name(ptr);
18943 return symtab_list_[index].local_data();
18948 return symtab_list_[index].local_data();
18953 return symtab_list_[index];
18960 : type_check_enabled(true)
18967 parsing_return_stmt =
false;
18968 parsing_break_stmt =
false;
18969 return_stmt_present =
false;
18970 side_effect_present =
false;
18974 #ifndef exprtk_enable_debugging
18977 void activate_side_effect(
const std::string& source)
18980 if (!side_effect_present)
18982 side_effect_present =
true;
18984 exprtk_debug((
"activate_side_effect() - caller: %s\n",source.c_str()));
19003 e_usr_variable_type = 0,
19004 e_usr_constant_type = 1
19009 e_usrmode_default = 0,
19010 e_usrmode_extended = 1
19025 std::string& error_message)
19027 if (e_usrmode_default != mode)
19030 st = e_usr_variable_type;
19031 default_value = T(0);
19032 error_message.clear();
19048 e_ct_variables = 1,
19049 e_ct_functions = 2,
19050 e_ct_assignments = 4
19061 e_st_local_variable = 6,
19062 e_st_local_vector = 7,
19063 e_st_local_string = 8
19074 : options_(options),
19075 collect_variables_ ((options_ & e_ct_variables ) == e_ct_variables ),
19076 collect_functions_ ((options_ & e_ct_functions ) == e_ct_functions ),
19077 collect_assignments_((options_ & e_ct_assignments) == e_ct_assignments),
19078 return_present_ (false),
19079 final_stmt_return_(false)
19082 template <
typename Allocator,
19083 template <
typename,
typename>
class Sequence>
19084 inline std::size_t
symbols(Sequence<symbol_t,Allocator>& symbols_list)
19086 if (!collect_variables_ && !collect_functions_)
19088 else if (symbol_name_list_.empty())
19091 for (std::size_t i = 0; i < symbol_name_list_.size(); ++i)
19096 std::sort(symbol_name_list_.begin(),symbol_name_list_.end());
19098 std::unique_copy(symbol_name_list_.begin(),
19099 symbol_name_list_.end (),
19100 std::back_inserter(symbols_list));
19102 return symbols_list.size();
19105 template <
typename Allocator,
19106 template <
typename,
typename>
class Sequence>
19109 if (!collect_assignments_)
19111 else if (assignment_name_list_.empty())
19114 for (std::size_t i = 0; i < assignment_name_list_.size(); ++i)
19119 std::sort(assignment_name_list_.begin(),assignment_name_list_.end());
19121 std::unique_copy(assignment_name_list_.begin(),
19122 assignment_name_list_.end (),
19123 std::back_inserter(assignment_list));
19125 return assignment_list.size();
19130 symbol_name_list_ .clear();
19131 assignment_name_list_.clear();
19132 retparam_list_ .clear();
19133 return_present_ =
false;
19134 final_stmt_return_ =
false;
19139 return collect_variables_;
19144 return collect_functions_;
19149 return collect_assignments_;
19154 return return_present_;
19159 return final_stmt_return_;
19166 return retparam_list_;
19175 case e_st_variable :
19178 case e_st_local_variable :
19179 case e_st_local_vector :
19180 case e_st_local_string :
if (collect_variables_)
19182 .push_back(std::make_pair(symbol, st));
19185 case e_st_function :
if (collect_functions_)
19187 .push_back(std::make_pair(symbol, st));
19198 case e_st_variable :
19200 case e_st_string :
if (collect_assignments_)
19201 assignment_name_list_
19202 .push_back(std::make_pair(symbol, st));
19219 friend class parser<T>;
19236 e_numeric_check = 4,
19237 e_bracket_check = 8,
19238 e_sequence_check = 16,
19239 e_commutative_check = 32,
19240 e_strength_reduction = 64,
19241 e_disable_vardef = 128,
19242 e_collect_vars = 256,
19243 e_collect_funcs = 512,
19244 e_collect_assings = 1024,
19245 e_disable_usr_on_rsrvd = 2048,
19246 e_disable_zero_return = 4096
19271 e_ctrl_unknown = 0,
19282 e_logic_unknown = 0,
19290 e_arith_unknown = 0,
19292 e_arith_div, e_arith_mod, e_arith_pow
19297 e_assign_unknown = 0,
19304 e_ineq_unknown = 0,
19310 static const std::size_t compile_all_opts = e_replacer +
19315 e_commutative_check +
19316 e_strength_reduction;
19320 load_compile_options(compile_options);
19325 disabled_func_set_.clear();
19331 disabled_ctrl_set_.clear();
19337 disabled_logic_set_.clear();
19343 disabled_arithmetic_set_.clear();
19349 disabled_assignment_set_.clear();
19355 disabled_inequality_set_.clear();
19361 disable_vardef_ =
false;
19369 std::insert_iterator<disabled_entity_set_t>
19370 (disabled_func_set_, disabled_func_set_.begin()));
19378 std::insert_iterator<disabled_entity_set_t>
19379 (disabled_ctrl_set_, disabled_ctrl_set_.begin()));
19387 std::insert_iterator<disabled_entity_set_t>
19388 (disabled_logic_set_, disabled_logic_set_.begin()));
19396 std::insert_iterator<disabled_entity_set_t>
19397 (disabled_arithmetic_set_, disabled_arithmetic_set_.begin()));
19405 std::insert_iterator<disabled_entity_set_t>
19406 (disabled_assignment_set_, disabled_assignment_set_.begin()));
19414 std::insert_iterator<disabled_entity_set_t>
19415 (disabled_inequality_set_, disabled_inequality_set_.begin()));
19421 disable_vardef_ =
true;
19441 if (disabled_func_set_.empty())
19444 return (disabled_func_set_.end() == disabled_func_set_.find(function_name));
19449 if (disabled_ctrl_set_.empty())
19452 return (disabled_ctrl_set_.end() == disabled_ctrl_set_.find(control_struct));
19457 if (disabled_logic_set_.empty())
19460 return (disabled_logic_set_.end() == disabled_logic_set_.find(logic_operation));
19465 if (disabled_logic_set_.empty())
19468 return disabled_arithmetic_set_.end() == disabled_arithmetic_set_
19469 .find(arith_opr_to_string(arithmetic_operation));
19474 if (disabled_assignment_set_.empty())
19477 return disabled_assignment_set_.end() == disabled_assignment_set_
19478 .find(assign_opr_to_string(assignment));
19483 if (disabled_inequality_set_.empty())
19486 return disabled_inequality_set_.end() == disabled_inequality_set_
19487 .find(inequality_opr_to_string(inequality));
19492 if (disabled_func_set_.empty())
19495 return (disabled_func_set_.end() != disabled_func_set_.find(function_name));
19500 if (disabled_ctrl_set_.empty())
19503 return (disabled_ctrl_set_.end() != disabled_ctrl_set_.find(control_struct));
19508 if (disabled_logic_set_.empty())
19511 return (disabled_logic_set_.end() != disabled_logic_set_.find(logic_operation));
19516 if (disabled_assignment_set_.empty())
19519 return disabled_assignment_set_.end() != disabled_assignment_set_
19520 .find(assign_opr_to_string(assignment_operation));
19525 if (disabled_arithmetic_set_.empty())
19528 return disabled_arithmetic_set_.end() != disabled_arithmetic_set_
19529 .find(arith_opr_to_string(arithmetic_operation));
19534 if (disabled_inequality_set_.empty())
19537 return disabled_inequality_set_.end() != disabled_inequality_set_
19538 .find(inequality_opr_to_string(inequality));
19544 (e_bf_unknown != bf) &&
19557 (e_ctrl_unknown != ctrl_struct) &&
19570 (e_logic_unknown != logic) &&
19583 (e_arith_unknown != arithmetic) &&
19596 (e_assign_unknown != assignment) &&
19609 (e_ineq_unknown != inequality) &&
19622 (e_bf_unknown != bf) &&
19628 if (disabled_func_set_.end() != itr)
19630 disabled_func_set_.erase(itr);
19640 (e_ctrl_unknown != ctrl_struct) &&
19646 if (disabled_ctrl_set_.end() != itr)
19648 disabled_ctrl_set_.erase(itr);
19658 (e_logic_unknown != logic) &&
19664 if (disabled_logic_set_.end() != itr)
19666 disabled_logic_set_.erase(itr);
19676 (e_arith_unknown != arithmetic) &&
19682 if (disabled_arithmetic_set_.end() != itr)
19684 disabled_arithmetic_set_.erase(itr);
19694 (e_assign_unknown != assignment) &&
19700 if (disabled_assignment_set_.end() != itr)
19702 disabled_assignment_set_.erase(itr);
19712 (e_ineq_unknown != inequality) &&
19718 if (disabled_inequality_set_.end() != itr)
19720 disabled_inequality_set_.erase(itr);
19731 enable_replacer_ = (compile_options & e_replacer ) == e_replacer;
19732 enable_joiner_ = (compile_options & e_joiner ) == e_joiner;
19733 enable_numeric_check_ = (compile_options & e_numeric_check ) == e_numeric_check;
19734 enable_bracket_check_ = (compile_options & e_bracket_check ) == e_bracket_check;
19735 enable_sequence_check_ = (compile_options & e_sequence_check ) == e_sequence_check;
19736 enable_commutative_check_ = (compile_options & e_commutative_check ) == e_commutative_check;
19737 enable_strength_reduction_ = (compile_options & e_strength_reduction ) == e_strength_reduction;
19738 enable_collect_vars_ = (compile_options & e_collect_vars ) == e_collect_vars;
19739 enable_collect_funcs_ = (compile_options & e_collect_funcs ) == e_collect_funcs;
19740 enable_collect_assings_ = (compile_options & e_collect_assings ) == e_collect_assings;
19741 disable_vardef_ = (compile_options & e_disable_vardef ) == e_disable_vardef;
19742 disable_rsrvd_sym_usr_ = (compile_options & e_disable_usr_on_rsrvd) == e_disable_usr_on_rsrvd;
19743 disable_zero_return_ = (compile_options & e_disable_zero_return ) == e_disable_zero_return;
19756 default :
return "";
19769 default :
return "";
19785 default :
return "";
19810 friend class parser<T>;
19816 : settings_(settings),
19817 resolve_unknown_symbol_(false),
19818 results_context_(0),
19821 #pragma warning(push)
19822 #pragma warning (disable:4355)
19826 #pragma warning(pop)
19828 operator_joiner_2_(2),
19829 operator_joiner_3_(3)
19831 init_precompilation();
19834 load_unary_operations_map (unary_op_map_ );
19835 load_binary_operations_map (binary_op_map_ );
19836 load_inv_binary_operations_map(inv_binary_op_map_);
19837 load_sf3_map (sf3_map_ );
19838 load_sf4_map (sf4_map_ );
19840 expression_generator_.init_synthesize_map();
19841 expression_generator_.set_parser(*
this);
19842 expression_generator_.set_uom(unary_op_map_);
19843 expression_generator_.set_bom(binary_op_map_);
19844 expression_generator_.set_ibom(inv_binary_op_map_);
19845 expression_generator_.set_sf3m(sf3_map_);
19846 expression_generator_.set_sf4m(sf4_map_);
19847 expression_generator_.set_strength_reduction_state(settings_.strength_reduction_enabled());
19855 if (settings_.collect_variables_enabled())
19856 dec_.collect_variables() =
true;
19858 if (settings_.collect_functions_enabled())
19859 dec_.collect_functions() =
true;
19861 if (settings_.collect_assignments_enabled())
19862 dec_.collect_assignments() =
true;
19864 if (settings_.replacer_enabled())
19866 symbol_replacer_.clear();
19869 helper_assembly_.token_modifier_list.clear();
19870 helper_assembly_.register_modifier(&symbol_replacer_);
19873 if (settings_.commutative_check_enabled())
19880 helper_assembly_.token_inserter_list.clear();
19881 helper_assembly_.register_inserter(&commutative_inserter_);
19884 if (settings_.joiner_enabled())
19886 helper_assembly_.token_joiner_list.clear();
19887 helper_assembly_.register_joiner(&operator_joiner_2_);
19888 helper_assembly_.register_joiner(&operator_joiner_3_);
19892 settings_.numeric_check_enabled () ||
19893 settings_.bracket_check_enabled () ||
19894 settings_.sequence_check_enabled()
19897 helper_assembly_.token_scanner_list.clear();
19899 if (settings_.numeric_check_enabled())
19901 helper_assembly_.register_scanner(&numeric_checker_);
19904 if (settings_.bracket_check_enabled())
19906 helper_assembly_.register_scanner(&bracket_checker_);
19909 if (settings_.sequence_check_enabled())
19911 helper_assembly_.register_scanner(&sequence_validator_);
19919 error_list_ .clear();
19920 brkcnt_list_ .clear();
19921 synthesis_error_.clear();
19926 expression_generator_.set_allocator(node_allocator_);
19928 if (expression_string.empty())
19932 "ERR000 - Empty expression!",
19938 if (!
init(expression_string))
19940 process_lexer_errors();
19944 if (lexer().empty())
19948 "ERR001 - Empty expression!",
19954 if (!run_assemblies())
19968 if ((0 != e) && (token_t::e_eof == current_token().
type))
19970 bool* retinvk_ptr = 0;
19972 if (state_.return_stmt_present)
19974 dec_.return_present_ =
true;
19976 e = expression_generator_
19977 .return_envelope(e,results_context_,retinvk_ptr);
19983 register_local_vars(expr);
19984 register_return_results(expr);
19990 if (error_list_.empty())
19995 "ERR002 - Invalid expression encountered",
20018 compile(expression_string,expr);
20025 for (std::size_t i = 0; i < lexer().size(); ++i)
20027 if (lexer()[i].is_error())
20029 std::string diagnostic =
"ERR003 - ";
20031 switch (lexer()[i].type)
20048 default : diagnostic +=
"Unknown compiler error";
20054 diagnostic +
": " + lexer()[i].
value,
20062 if (settings_.commutative_check_enabled())
20064 helper_assembly_.run_inserters(lexer());
20067 if (settings_.joiner_enabled())
20069 helper_assembly_.run_joiners(lexer());
20072 if (settings_.replacer_enabled())
20074 helper_assembly_.run_modifiers(lexer());
20078 settings_.numeric_check_enabled () ||
20079 settings_.bracket_check_enabled () ||
20080 settings_.sequence_check_enabled()
20083 if (!helper_assembly_.run_scanners(lexer()))
20085 if (helper_assembly_.error_token_scanner)
20091 if (0 != (bracket_checker_ptr = dynamic_cast<lexer::helper::bracket_checker*>(helper_assembly_.error_token_scanner)))
20096 "ERR004 - Mismatched brackets: '" + bracket_checker_ptr->
error_token().
value +
"'",
20099 else if (0 != (numeric_checker_ptr = dynamic_cast<lexer::helper::numeric_checker*>(helper_assembly_.error_token_scanner)))
20101 for (std::size_t i = 0; i < numeric_checker_ptr->
error_count(); ++i)
20108 "ERR005 - Invalid numeric token: '" + error_token.
value +
"'",
20117 else if (0 != (sequence_validator_ptr = dynamic_cast<lexer::helper::sequence_validator*>(helper_assembly_.error_token_scanner)))
20119 for (std::size_t i = 0; i < sequence_validator_ptr->
error_count(); ++i)
20121 std::pair<lexer::token,lexer::token> error_token = sequence_validator_ptr->
error(i);
20126 "ERR006 - Invalid token sequence: '" +
20127 error_token.first.value +
"' and '" +
20128 error_token.second.value +
"'",
20153 if (index < error_list_.size())
20154 return error_list_[index];
20156 throw std::invalid_argument(
"parser::get_error() - Invalid error index specificed");
20161 if (!error_list_.empty())
20163 return error_list_[0].diagnostic;
20166 return std::string(
"No Error");
20171 return error_list_.size();
20181 if (!settings_.replacer_enabled())
20191 if (!settings_.replacer_enabled())
20196 return symbol_replacer_.remove(symbol);
20201 resolve_unknown_symbol_ =
true;
20204 unknown_symbol_resolver_ = usr;
20206 unknown_symbol_resolver_ = &default_usr_;
20211 enable_unknown_symbol_resolver(&usr);
20216 resolve_unknown_symbol_ =
false;
20217 unknown_symbol_resolver_ = &default_usr_;
20224 const std::size_t length = symbol.size();
20232 return settings_.function_enabled(symbol) &&
20233 (base_ops_map_.end() != base_ops_map_.find(symbol));
20238 static const std::string s_sum =
"sum" ;
20239 static const std::string s_mul =
"mul" ;
20240 static const std::string s_avg =
"avg" ;
20241 static const std::string s_min =
"min" ;
20242 static const std::string s_max =
"max" ;
20243 static const std::string s_mand =
"mand";
20244 static const std::string s_mor =
"mor" ;
20245 static const std::string s_multi =
"~" ;
20246 static const std::string s_mswitch =
"[*]" ;
20260 settings_.function_enabled(symbol);
20265 return settings_.arithmetic_disabled(operation);
20270 return settings_.assignment_disabled(operation);
20275 return settings_.inequality_disabled(operation);
20278 #ifdef exprtk_enable_debugging
20279 inline void next_token()
20281 std::string ct_str = current_token().value;
20282 parser_helper::next_token();
20283 std::string depth(2 * state_.scope_depth,
' ');
20285 "prev[%s] --> curr[%s]\n",
20288 current_token().value.c_str()));
20294 std::vector<expression_node_ptr> arg_list;
20295 std::vector<bool> side_effect_list;
20306 state_.side_effect_present =
false;
20308 begin_token = current_token();
20314 if (error_list_.empty())
20319 "ERR007 - Invalid expression encountered",
20323 return error_node();
20327 arg_list.push_back(arg);
20329 side_effect_list.push_back(state_.side_effect_present);
20331 end_token = current_token();
20333 std::string sub_expr = construct_subexpr(begin_token,end_token);
20336 static_cast<int>(arg_list.size() - 1),
20337 sub_expr.c_str()));
20339 exprtk_debug((
"parse_corpus(%02d) - Side effect present: %s\n",
20340 static_cast<int>(arg_list.size() - 1),
20341 state_.side_effect_present ?
"true" :
"false"));
20343 exprtk_debug((
"-------------------------------------------------\n"));
20346 if (lexer().finished())
20348 else if (token_is(token_t::e_eof,prsrhlpr_t::e_hold))
20350 if (lexer().finished())
20358 !arg_list.empty() &&
20362 dec_.final_stmt_return_ =
true;
20365 result = simplify(arg_list,side_effect_list);
20374 std::string result = lexer().substr(begin_token.
position,end_token.
position);
20376 for (std::size_t i = 0; i < result.size(); ++i)
20413 if (0 == expression)
20415 return error_node();
20418 bool break_loop =
false;
20424 current_state.
reset();
20426 switch (current_token().
type)
20447 default :
if (token_t::e_symbol == current_token().
type)
20449 static const std::string s_and =
"and";
20450 static const std::string s_nand =
"nand";
20451 static const std::string s_or =
"or";
20452 static const std::string s_nor =
"nor";
20453 static const std::string s_xor =
"xor";
20454 static const std::string s_xnor =
"xnor";
20455 static const std::string s_in =
"in";
20456 static const std::string s_like =
"like";
20457 static const std::string s_ilike =
"ilike";
20458 static const std::string s_and1 =
"&";
20459 static const std::string s_or1 =
"|";
20460 static const std::string s_not =
"not";
20469 #ifndef exprtk_disable_sc_andor
20488 #ifndef exprtk_disable_sc_andor
20536 parse_pending_string_rangesize(expression);
20539 else if (current_state.
left < precedence)
20549 if (is_invalid_arithmetic_operation(current_state.
operation))
20559 return error_node();
20561 else if (is_invalid_inequality_operation(current_state.
operation))
20571 return error_node();
20573 else if (is_invalid_assignment_operation(current_state.
operation))
20583 return error_node();
20586 if (0 != (right_branch = parse_expression(current_state.
right)))
20593 free_node(node_allocator_, expression);
20594 free_node(node_allocator_, right_branch);
20599 "ERR011 - Return statements cannot be part of sub-expressions",
20602 return error_node();
20605 new_expression = expression_generator_
20613 if (0 == new_expression)
20615 if (error_list_.empty())
20620 !synthesis_error_.empty() ?
20622 "ERR012 - General parsing error at token: '" + prev_token.
value +
"'",
20626 free_node(node_allocator_, expression);
20627 free_node(node_allocator_, right_branch);
20629 return error_node();
20634 token_is(token_t::e_ternary,prsrhlpr_t::e_hold) &&
20635 (precedence == e_level00)
20638 expression = parse_ternary_conditional_statement(new_expression);
20641 expression = new_expression;
20643 parse_pending_string_rangesize(expression);
20654 ubn_t* n =
dynamic_cast<ubn_t*
>(node);
20670 uvn_t* n =
dynamic_cast<uvn_t*
>(node);
20674 const T&
v = n->v();
20678 (0 != (return_node = symtab_store_.get_variable(v))) ||
20679 (0 != (return_node = sem_ .get_variable(v)))
20683 node = return_node;
20692 "ERR013 - Failed to find variable node in symbol table",
20710 template <
typename Type, std::
size_t N>
20716 : delete_ptr(true),
20722 : delete_ptr(true),
20731 for (std::size_t i = 0; i < N; ++i)
20733 free_node(parser_.node_allocator_,p_[i]);
20747 template <
typename Type>
20753 : delete_ptr(true),
20760 if (delete_ptr && !deq_.empty())
20762 for (std::size_t i = 0; i < deq_.size(); ++i)
20764 free_node(parser_.node_allocator_,deq_[i]);
20780 template <
typename Type>
20786 : delete_ptr(true),
20793 if (delete_ptr && !vec_.empty())
20795 for (std::size_t i = 0; i < vec_.size(); ++i)
20797 free_node(parser_.node_allocator_,vec_[i]);
20829 original_value_(bb)
20834 b = b || original_value_;
20845 switch (function->param_count)
20847 case 0 : func_node = parse_function_call_0 (
function,function_name);
break;
20848 case 1 : func_node = parse_function_call< 1>(
function,function_name);
break;
20849 case 2 : func_node = parse_function_call< 2>(
function,function_name);
break;
20850 case 3 : func_node = parse_function_call< 3>(
function,function_name);
break;
20851 case 4 : func_node = parse_function_call< 4>(
function,function_name);
break;
20852 case 5 : func_node = parse_function_call< 5>(
function,function_name);
break;
20853 case 6 : func_node = parse_function_call< 6>(
function,function_name);
break;
20854 case 7 : func_node = parse_function_call< 7>(
function,function_name);
break;
20855 case 8 : func_node = parse_function_call< 8>(
function,function_name);
break;
20856 case 9 : func_node = parse_function_call< 9>(
function,function_name);
break;
20857 case 10 : func_node = parse_function_call<10>(
function,function_name);
break;
20858 case 11 : func_node = parse_function_call<11>(
function,function_name);
break;
20859 case 12 : func_node = parse_function_call<12>(
function,function_name);
break;
20860 case 13 : func_node = parse_function_call<13>(
function,function_name);
break;
20861 case 14 : func_node = parse_function_call<14>(
function,function_name);
break;
20862 case 15 : func_node = parse_function_call<15>(
function,function_name);
break;
20863 case 16 : func_node = parse_function_call<16>(
function,function_name);
break;
20864 case 17 : func_node = parse_function_call<17>(
function,function_name);
break;
20865 case 18 : func_node = parse_function_call<18>(
function,function_name);
break;
20866 case 19 : func_node = parse_function_call<19>(
function,function_name);
break;
20867 case 20 : func_node = parse_function_call<20>(
function,function_name);
break;
20872 "ERR014 - Invalid number of parameters for function: '" + function_name +
"'",
20875 return error_node();
20886 "ERR015 - Failed to generate call to function: '" + function_name +
"'",
20889 return error_node();
20893 template <std::
size_t NumberofParameters>
20897 #pragma warning(push)
20898 #pragma warning(disable: 4127)
20900 if (0 == NumberofParameters)
20905 "ERR016 - Expecting ifunction '" + function_name +
"' to have non-zero parameter count",
20908 return error_node();
20911 #pragma warning(pop)
20917 std::fill_n(branch, NumberofParameters, reinterpret_cast<expression_node_ptr>(0));
20923 if (!token_is(token_t::e_lbracket))
20928 "ERR017 - Expecting argument list for function: '" + function_name +
"'",
20931 return error_node();
20934 for (
int i = 0; i < static_cast<int>(NumberofParameters); ++i)
20936 branch[i] = parse_expression();
20938 if (0 == branch[i])
20943 "ERR018 - Failed to parse argument " +
details::to_str(i) +
" for function: '" + function_name +
"'",
20946 return error_node();
20948 else if (i < static_cast<int>(NumberofParameters - 1))
20950 if (!token_is(token_t::e_comma))
20955 "ERR019 - Invalid number of arguments for function: '" + function_name +
"'",
20958 return error_node();
20963 if (!token_is(token_t::e_rbracket))
20968 "ERR020 - Invalid number of arguments for function: '" + function_name +
"'",
20971 return error_node();
20974 result = expression_generator_.function(
function,branch);
20985 state_.side_effect_present =
function->has_side_effects();
20990 token_is(token_t::e_lbracket) &&
20991 !token_is(token_t::e_rbracket)
20997 "ERR021 - Expecting '()' to proceed call to function: '" + function_name +
"'",
21002 return error_node();
21008 template <std::
size_t MaxNumberofParameters>
21011 std::fill_n(param_list, MaxNumberofParameters, reinterpret_cast<expression_node_ptr>(0));
21017 if (!token_is(token_t::e_lbracket))
21022 "ERR022 - Expected a '(' at start of function call to '" + function_name +
21023 "', instead got: '" + current_token().
value +
"'",
21029 if (token_is(token_t::e_rbracket, e_hold))
21034 "ERR023 - Expected at least one input parameter for function call '" + function_name +
"'",
21040 std::size_t param_index = 0;
21042 for (; param_index < MaxNumberofParameters; ++param_index)
21044 param_list[param_index] = parse_expression();
21046 if (0 == param_list[param_index])
21048 else if (token_is(token_t::e_rbracket))
21053 else if (token_is(token_t::e_comma))
21060 "ERR024 - Expected a ',' between function input parameters, instead got: '" + current_token().
value +
"'",
21072 "ERR025 - Invalid number of input parameters passed to function '" + function_name +
"'",
21078 return (param_index + 1);
21083 typedef std::pair<base_ops_map_t::iterator,base_ops_map_t::iterator> map_range_t;
21085 const std::string operation_name = current_token().
value;
21086 const token_t diagnostic_token = current_token();
21088 map_range_t itr_range = base_ops_map_.equal_range(operation_name);
21090 if (0 == std::distance(itr_range.first,itr_range.second))
21095 "ERR026 - No entry found for base operation: " + operation_name,
21098 return error_node();
21101 static const std::size_t MaxNumberofParameters = 4;
21104 const std::size_t parameter_count = parse_base_function_call(param_list, operation_name);
21106 if ((parameter_count > 0) && (parameter_count <= MaxNumberofParameters))
21108 for (base_ops_map_t::iterator itr = itr_range.first; itr != itr_range.second; ++itr)
21112 if (operation.
num_params == parameter_count)
21114 switch (parameter_count)
21116 #define base_opr_case(N) \
21118 expression_node_ptr pl##N[N] = {0}; \
21119 std::copy(param_list, param_list + N, pl##N); \
21120 lodge_symbol(operation_name, e_st_function); \
21121 return expression_generator_(operation.type, pl##N); \
21128 #undef base_opr_case
21134 for (std::size_t i = 0; i < MaxNumberofParameters; ++i)
21136 free_node(node_allocator_, param_list[i]);
21142 "ERR027 - Invalid number of input parameters for call to function: '" + operation_name +
"'",
21145 return error_node();
21155 bool result =
true;
21157 if (!token_is(token_t::e_comma))
21162 "ERR028 - Expected ',' between if-statement condition and consequent",
21166 else if (0 == (consequent = parse_expression()))
21171 "ERR029 - Failed to parse consequent for if-statement",
21175 else if (!token_is(token_t::e_comma))
21180 "ERR030 - Expected ',' between if-statement consequent and alternative",
21184 else if (0 == (alternative = parse_expression()))
21189 "ERR031 - Failed to parse alternative for if-statement",
21193 else if (!token_is(token_t::e_rbracket))
21198 "ERR032 - Expected ')' at the end of if-statement",
21203 #ifndef exprtk_disable_string_capabilities
21209 if (consq_is_str || alter_is_str)
21211 if (consq_is_str && alter_is_str)
21213 return expression_generator_
21214 .conditional_string(condition,consequent,alternative);
21220 "ERR033 - Return types of ternary if-statement differ",
21231 free_node(node_allocator_, consequent);
21232 free_node(node_allocator_,alternative);
21234 return error_node();
21237 return expression_generator_
21238 .conditional(condition,consequent,alternative);
21246 bool result =
true;
21248 if (token_is(token_t::e_lcrlbracket,prsrhlpr_t::e_hold))
21250 if (0 == (consequent = parse_multi_sequence(
"if-statement-01")))
21255 "ERR034 - Failed to parse body of consequent for if-statement",
21264 settings_.commutative_check_enabled() &&
21271 if (0 != (consequent = parse_expression()))
21273 if (!token_is(token_t::e_eof))
21278 "ERR035 - Expected ';' at the end of the consequent for if-statement",
21289 "ERR036 - Failed to parse body of consequent for if-statement",
21302 if (token_is(token_t::e_lcrlbracket,prsrhlpr_t::e_hold))
21304 if (0 == (alternative = parse_multi_sequence(
"else-statement-01")))
21309 "ERR037 - Failed to parse body of the 'else' for if-statement",
21317 if (0 == (alternative = parse_conditional_statement()))
21322 "ERR038 - Failed to parse body of if-else statement",
21328 else if (0 != (alternative = parse_expression()))
21330 if (!token_is(token_t::e_eof))
21335 "ERR039 - Expected ';' at the end of the 'else-if' for the if-statement",
21346 "ERR040 - Failed to parse body of the 'else' for if-statement",
21354 #ifndef exprtk_disable_string_capabilities
21360 if (consq_is_str || alter_is_str)
21362 if (consq_is_str && alter_is_str)
21364 return expression_generator_
21365 .conditional_string(condition, consequent, alternative);
21371 "ERR041 - Return types of ternary if-statement differ",
21382 free_node(node_allocator_, consequent);
21383 free_node(node_allocator_, alternative);
21385 return error_node();
21388 return expression_generator_
21389 .conditional(condition, consequent, alternative);
21398 if (!token_is(token_t::e_lbracket))
21403 "ERR042 - Expected '(' at start of if-statement, instead got: '" + current_token().
value +
"'",
21406 return error_node();
21408 else if (0 == (condition = parse_expression()))
21413 "ERR043 - Failed to parse condition for if-statement",
21416 return error_node();
21418 else if (token_is(token_t::e_comma,prsrhlpr_t::e_hold))
21421 return parse_conditional_statement_01(condition);
21423 else if (token_is(token_t::e_rbracket))
21439 return parse_conditional_statement_02(condition);
21445 "ERR044 - Invalid if-statement",
21450 return error_node();
21459 bool result =
true;
21461 if (0 == condition)
21466 "ERR045 - Encountered invalid condition branch for ternary if-statement",
21469 return error_node();
21471 else if (!token_is(token_t::e_ternary))
21476 "ERR046 - Expected '?' after condition of ternary if-statement",
21481 else if (0 == (consequent = parse_expression()))
21486 "ERR047 - Failed to parse consequent for ternary if-statement",
21491 else if (!token_is(token_t::e_colon))
21496 "ERR048 - Expected ':' between ternary if-statement consequent and alternative",
21501 else if (0 == (alternative = parse_expression()))
21506 "ERR049 - Failed to parse alternative for ternary if-statement",
21512 #ifndef exprtk_disable_string_capabilities
21518 if (consq_is_str || alter_is_str)
21520 if (consq_is_str && alter_is_str)
21522 return expression_generator_
21523 .conditional_string(condition, consequent, alternative);
21529 "ERR050 - Return types of ternary if-statement differ",
21540 free_node(node_allocator_, consequent);
21541 free_node(node_allocator_, alternative);
21543 return error_node();
21546 return expression_generator_
21547 .conditional(condition, consequent, alternative);
21557 bool result =
true;
21561 if (!token_is(token_t::e_lbracket))
21566 "ERR051 - Expected '(' at start of while-loop condition statement",
21569 return error_node();
21571 else if (0 == (condition = parse_expression()))
21576 "ERR052 - Failed to parse condition for while-loop",
21579 return error_node();
21581 else if (!token_is(token_t::e_rbracket))
21586 "ERR053 - Expected ')' at end of while-loop condition statement",
21592 brkcnt_list_.push_front(
false);
21596 if (0 == (branch = parse_multi_sequence(
"while-loop")))
21601 "ERR054 - Failed to parse body of while-loop"));
21604 else if (0 == (result_node = expression_generator_.while_loop(condition,
21606 brkcnt_list_.front())))
21611 "ERR055 - Failed to synthesize while-loop",
21622 free_node(node_allocator_, result_node);
21624 brkcnt_list_.pop_front();
21626 return error_node();
21629 return result_node;
21639 std::vector<expression_node_ptr> arg_list;
21640 std::vector<bool> side_effect_list;
21644 brkcnt_list_.push_front(
false);
21661 state_.side_effect_present =
false;
21666 return error_node();
21669 arg_list.push_back(arg);
21670 side_effect_list.push_back(state_.side_effect_present);
21679 bool is_next_until = peek_token_is(token_t::e_symbol) &&
21680 peek_token_is(
"until");
21682 if (!token_is(seperator) && is_next_until)
21687 "ERR056 - Expected '" +
token_t::to_str(seperator) +
"' in body of repeat until loop",
21690 return error_node();
21700 branch = simplify(arg_list,side_effect_list);
21706 brkcnt_list_.pop_front();
21711 "ERR057 - Failed to parse body of repeat until loop",
21714 return error_node();
21718 if (!token_is(token_t::e_lbracket))
21720 brkcnt_list_.pop_front();
21725 "ERR058 - Expected '(' before condition statement of repeat until loop",
21730 return error_node();
21732 else if (0 == (condition = parse_expression()))
21734 brkcnt_list_.pop_front();
21739 "ERR059 - Failed to parse condition for repeat until loop",
21744 return error_node();
21746 else if (!token_is(token_t::e_rbracket))
21751 "ERR060 - Expected ')' after condition of repeat until loop",
21757 brkcnt_list_.pop_front();
21759 return error_node();
21764 result = expression_generator_
21765 .repeat_until_loop(condition, branch, brkcnt_list_.front());
21772 "ERR061 - Failed to synthesize repeat until loop",
21777 brkcnt_list_.pop_front();
21779 return error_node();
21783 brkcnt_list_.pop_front();
21796 bool result =
true;
21797 std::string loop_counter_symbol;
21803 if (!token_is(token_t::e_lbracket))
21808 "ERR062 - Expected '(' at start of for-loop",
21811 return error_node();
21814 if (!token_is(token_t::e_eof))
21817 !token_is(token_t::e_symbol,prsrhlpr_t::e_hold) &&
21823 if (!token_is(token_t::e_symbol,prsrhlpr_t::e_hold))
21828 "ERR063 - Expected a variable at the start of initialiser section of for-loop",
21831 return error_node();
21838 "ERR064 - Expected variable assignment of initialiser section of for-loop",
21841 return error_node();
21844 loop_counter_symbol = current_token().value;
21846 se = &sem_.get_element(loop_counter_symbol);
21848 if ((se->
name == loop_counter_symbol) && se->
active)
21853 "ERR065 - For-loop variable '" + loop_counter_symbol+
"' is being shadowed by a previous declaration",
21856 return error_node();
21858 else if (!symtab_store_.is_variable(loop_counter_symbol))
21862 (se->
name == loop_counter_symbol) &&
21863 (se->
type == scope_element::e_variable)
21872 nse.
name = loop_counter_symbol;
21875 nse.
type = scope_element::e_variable;
21876 nse.
depth = state_.scope_depth;
21877 nse.
data =
new T(T(0));
21880 if (!sem_.add_element(nse))
21885 "ERR066 - Failed to add new local variable '" + loop_counter_symbol +
"' to SEM",
21888 sem_.free_element(nse);
21894 exprtk_debug((
"parse_for_loop() - INFO - Added new local variable: %s\n",nse.
name.c_str()));
21896 state_.activate_side_effect(
"parse_for_loop()");
21902 if (0 == (initialiser = parse_expression()))
21907 "ERR067 - Failed to parse initialiser of for-loop",
21912 else if (!token_is(token_t::e_eof))
21917 "ERR068 - Expected ';' after initialiser of for-loop",
21924 if (!token_is(token_t::e_eof))
21926 if (0 == (condition = parse_expression()))
21931 "ERR069 - Failed to parse condition of for-loop",
21936 else if (!token_is(token_t::e_eof))
21941 "ERR070 - Expected ';' after condition section of for-loop",
21948 if (!token_is(token_t::e_rbracket))
21950 if (0 == (incrementor = parse_expression()))
21955 "ERR071 - Failed to parse incrementor of for-loop",
21960 else if (!token_is(token_t::e_rbracket))
21965 "ERR072 - Expected ')' after incrementor section of for-loop",
21974 brkcnt_list_.push_front(
false);
21976 if (0 == (loop_body = parse_multi_sequence(
"for-loop")))
21981 "ERR073 - Failed to parse body of for-loop",
21997 free_node(node_allocator_, initialiser);
21999 free_node(node_allocator_, incrementor);
22002 if (!brkcnt_list_.empty())
22004 brkcnt_list_.pop_front();
22007 return error_node();
22012 expression_generator_.for_loop(initialiser,
22016 brkcnt_list_.front());
22017 brkcnt_list_.pop_front();
22019 return result_node;
22025 std::vector<expression_node_ptr> arg_list;
22033 "ERR074 - Expected keyword 'switch'",
22036 return error_node();
22043 if (!token_is(token_t::e_lcrlbracket))
22048 "ERR075 - Expected '{' for call to switch statement",
22051 return error_node();
22061 "ERR076 - Expected either a 'case' or 'default' statement",
22064 return error_node();
22071 if (0 == condition)
22072 return error_node();
22073 else if (!token_is(token_t::e_colon))
22078 "ERR077 - Expected ':' for case of switch statement",
22081 return error_node();
22086 if (0 == consequent)
22087 return error_node();
22088 else if (!token_is(token_t::e_eof))
22093 "ERR078 - Expected ';' at end of case for switch statement",
22096 return error_node();
22103 free_node(node_allocator_, consequent);
22107 arg_list.push_back( condition);
22108 arg_list.push_back(consequent);
22114 if (!token_is(token_t::e_colon))
22119 "ERR079 - Expected ':' for default of switch statement",
22122 return error_node();
22127 if (token_is(token_t::e_lcrlbracket,prsrhlpr_t::e_hold))
22128 default_statement = parse_multi_sequence(
"switch-default");
22130 default_statement = parse_expression();
22132 if (0 == default_statement)
22133 return error_node();
22134 else if (!token_is(token_t::e_eof))
22136 free_node(node_allocator_,default_statement);
22141 "ERR080 - Expected ';' at end of default for switch statement",
22144 return error_node();
22147 arg_list.push_back(default_statement);
22152 if (!token_is(token_t::e_rcrlbracket))
22157 "ERR081 - Expected '}' at end of switch statement",
22160 return error_node();
22163 result = expression_generator_.switch_statement(arg_list);
22172 std::vector<expression_node_ptr> arg_list;
22180 "ERR082 - Expected token '[*]'",
22183 return error_node();
22190 if (!token_is(token_t::e_lcrlbracket))
22195 "ERR083 - Expected '{' for call to [*] statement",
22198 return error_node();
22208 "ERR084 - Expected a 'case' statement for multi-switch",
22211 return error_node();
22218 if (0 == condition)
22219 return error_node();
22221 if (!token_is(token_t::e_colon))
22226 "ERR085 - Expected ':' for case of [*] statement",
22229 return error_node();
22234 if (0 == consequent)
22235 return error_node();
22237 if (!token_is(token_t::e_eof))
22242 "ERR086 - Expected ';' at end of case for [*] statement",
22245 return error_node();
22252 free_node(node_allocator_, consequent);
22256 arg_list.push_back(condition);
22257 arg_list.push_back(consequent);
22260 if (token_is(token_t::e_rcrlbracket,prsrhlpr_t::e_hold))
22266 if (!token_is(token_t::e_rcrlbracket))
22271 "ERR087 - Expected '}' at end of [*] statement",
22274 return error_node();
22277 result = expression_generator_.multi_switch_statement(arg_list);
22286 std::vector<expression_node_ptr> arg_list;
22290 const std::string symbol = current_token().value;
22295 return parse_multi_sequence();
22299 return parse_multi_switch_statement();
22313 "ERR088 - Unsupported vararg function: " + symbol,
22316 return error_node();
22321 lodge_symbol(symbol,e_st_function);
22325 if (!token_is(token_t::e_lbracket))
22330 "ERR089 - Expected '(' for call to vararg function: " + symbol,
22333 return error_node();
22341 return error_node();
22343 arg_list.push_back(arg);
22345 if (token_is(token_t::e_rbracket))
22347 else if (!token_is(token_t::e_comma))
22352 "ERR090 - Expected ',' for call to vararg function: " + symbol,
22355 return error_node();
22359 result = expression_generator_.vararg_function(opt_type,arg_list);
22365 #ifndef exprtk_disable_string_capabilities
22368 if (!token_is(token_t::e_lsqrbracket))
22373 "ERR091 - Expected '[' as start of string range definition",
22378 return error_node();
22380 else if (token_is(token_t::e_rsqrbracket))
22387 if (!parse_range(rp,
true))
22391 return error_node();
22401 "ERR092 - Failed to generate string range node",
22412 inline expression_node_ptr parse_string_range_statement(expression_node_ptr&)
22414 return error_node();
22421 const std::size_t max_rangesize_parses = 100;
22427 (0 != expression) &&
22428 (i++ < max_rangesize_parses) &&
22429 error_list_.empty() &&
22431 token_is(token_t::e_lsqrbracket,prsrhlpr_t::e_hold)
22434 expression = parse_string_range_statement(expression);
22438 template <
typename Allocator1,
22439 typename Allocator2,
22440 template <
typename,
typename>
class Sequence>
22442 Sequence<bool,Allocator2>& side_effect_list,
22443 const bool specialise_on_final_type =
false)
22445 if (expression_list.empty())
22446 return error_node();
22447 else if (1 == expression_list.size())
22448 return expression_list[0];
22450 Sequence<expression_node_ptr,Allocator1> tmp_expression_list;
22452 bool return_node_present =
false;
22454 for (std::size_t i = 0; i < (expression_list.size() - 1); ++i)
22464 tmp_expression_list.push_back(expression_list[i]);
22469 for (std::size_t j = i + 1; j < expression_list.size(); ++j)
22471 free_node(node_allocator_,expression_list[j]);
22474 return_node_present =
true;
22481 !side_effect_list[i]
22484 free_node(node_allocator_,expression_list[i]);
22488 tmp_expression_list.push_back(expression_list[i]);
22491 if (!return_node_present)
22493 tmp_expression_list.push_back(expression_list.back());
22496 expression_list.swap(tmp_expression_list);
22498 if (tmp_expression_list.size() > expression_list.size())
22500 exprtk_debug((
"simplify() - Reduced subexpressions from %d to %d\n",
22501 static_cast<int>(tmp_expression_list.size()),
22502 static_cast<int>(expression_list .size())));
22506 return_node_present ||
22507 side_effect_list.back() ||
22508 (expression_list.size() > 1)
22510 state_.activate_side_effect(
"simplify()");
22512 if (1 == expression_list.size())
22513 return expression_list[0];
22515 return expression_generator_.vararg_function(
details::e_smulti,expression_list);
22517 return expression_generator_.vararg_function(
details::e_multi,expression_list);
22525 if (!token_is(token_t::e_lcrlbracket))
22527 if (token_is(token_t::e_lbracket))
22529 close_bracket = token_t::e_rbracket;
22530 seperator = token_t::e_comma;
22537 "ERR093 - Expected '" +
token_t::to_str(close_bracket) +
"' for call to multi-sequence" +
22538 ((!source.empty()) ? std::string(
" section of " + source):
""),
22541 return error_node();
22544 else if (token_is(token_t::e_rcrlbracket))
22549 std::vector<expression_node_ptr> arg_list;
22550 std::vector<bool> side_effect_list;
22562 state_.side_effect_present =
false;
22567 return error_node();
22570 arg_list.push_back(arg);
22571 side_effect_list.push_back(state_.side_effect_present);
22574 if (token_is(close_bracket))
22577 bool is_next_close = peek_token_is(close_bracket);
22579 if (!token_is(seperator) && is_next_close)
22584 "ERR094 - Expected '" +
details::to_str(seperator) +
"' for call to multi-sequence section of " + source,
22587 return error_node();
22590 if (token_is(close_bracket))
22594 result = simplify(arg_list,side_effect_list,source.empty());
22613 if (!skip_lsqr && !token_is(token_t::e_lsqrbracket))
22618 "ERR095 - Expected '[' for start of range",
22624 if (token_is(token_t::e_colon))
22626 rp.
n0_c.first =
true;
22627 rp.
n0_c.second = 0;
22628 rp.
cache.first = 0;
22639 "ERR096 - Failed parse begin section of range",
22646 const T r0_value = r0->
value();
22648 if (r0_value >= T(0))
22650 rp.
n0_c.first =
true;
22657 if (r0_value < T(0))
22662 "ERR097 - Range lower bound less than zero! Constraint: r0 >= 0",
22670 rp.
n0_e.first =
true;
22671 rp.
n0_e.second = r0;
22674 if (!token_is(token_t::e_colon))
22679 "ERR098 - Expected ':' for break in range",
22688 if (token_is(token_t::e_rsqrbracket))
22690 rp.
n1_c.first =
true;
22702 "ERR099 - Failed parse end section of range",
22711 const T r1_value = r1->
value();
22713 if (r1_value >= T(0))
22715 rp.
n1_c.first =
true;
22722 if (r1_value < T(0))
22727 "ERR100 - Range upper bound less than zero! Constraint: r1 >= 0",
22735 rp.
n1_e.first =
true;
22736 rp.
n1_e.second = r1;
22739 if (!token_is(token_t::e_rsqrbracket))
22744 "ERR101 - Expected ']' for start of range",
22755 std::size_t r0 = 0;
22756 std::size_t r1 = 0;
22758 const bool rp_result = rp(r0,r1);
22760 if (!rp_result || (r0 > r1))
22765 "ERR102 - Invalid range, Constraint: r0 <= r1",
22778 dec_.add_symbol(symbol,st);
22781 #ifndef exprtk_disable_string_capabilities
22784 const std::string symbol = current_token().
value;
22789 strvar_node_t const_str_node =
static_cast<strvar_node_t
>(0);
22793 if (scope_element::e_string == se.
type)
22797 lodge_symbol(symbol,e_st_local_string);
22801 if (!symtab_store_.is_conststr_stringvar(symbol))
22806 "ERR103 - Unknown string symbol",
22809 return error_node();
22812 result = symtab_store_.get_stringvar(symbol);
22814 if (symtab_store_.is_constant_string(symbol))
22816 const_str_node =
static_cast<strvar_node_t
>(result);
22817 result = expression_generator_(const_str_node->str());
22820 lodge_symbol(symbol,e_st_string);
22823 if (peek_token_is(token_t::e_lsqrbracket))
22827 if (peek_token_is(token_t::e_rsqrbracket))
22832 if (const_str_node)
22836 return expression_generator_(T(const_str_node->size()));
22845 if (!parse_range(rp))
22849 return error_node();
22851 else if (const_str_node)
22854 result = expression_generator_(const_str_node->ref(),rp);
22858 (result)->ref(), rp);
22869 inline expression_node_ptr parse_string()
22871 return error_node();
22875 #ifndef exprtk_disable_string_capabilities
22878 const std::string const_str = current_token().
value;
22881 if (peek_token_is(token_t::e_lsqrbracket))
22885 if (peek_token_is(token_t::e_rsqrbracket))
22892 return expression_generator_(T(const_str.size()));
22897 if (!parse_range(rp))
22901 return error_node();
22908 rp.
n1_c.second = const_str.size() - 1;
22913 (rp.
n0_c.first && (rp.
n0_c.second >= const_str.size())) ||
22914 (rp.
n1_c.first && (rp.
n1_c.second >= const_str.size()))
22920 "ERR104 - Overflow in range for string: '" + const_str +
"'[" +
22925 return error_node();
22928 result = expression_generator_(const_str,rp);
22939 inline expression_node_ptr parse_const_string()
22941 return error_node();
22947 const std::string symbol = current_token().
value;
22949 vector_holder_ptr vec = vector_holder_ptr(0);
22955 (se.
depth > state_.scope_depth) ||
22956 (scope_element::e_vector != se.
type)
22959 if (0 == (vec = symtab_store_.get_vector(symbol)))
22964 "ERR105 - Symbol '" + symbol+
" not a vector",
22967 return error_node();
22977 if (!token_is(token_t::e_lsqrbracket))
22981 else if (token_is(token_t::e_rsqrbracket))
22983 return expression_generator_(T(vec->
size()));
22985 else if (0 == (index_expr = parse_expression()))
22990 "ERR106 - Failed to parse index for vector: '" + symbol +
"'",
22993 return error_node();
22995 else if (!token_is(token_t::e_rsqrbracket))
23000 "ERR107 - Expected ']' for index of vector: '" + symbol +
"'",
23005 return error_node();
23012 const std::size_t vec_size = vec->
size();
23014 if (index >= vec_size)
23025 return error_node();
23029 return expression_generator_.vector_element(symbol,vec,index_expr);
23034 std::vector<expression_node_ptr> arg_list;
23042 if (token_is(token_t::e_lbracket))
23044 if (token_is(token_t::e_rbracket))
23051 "ERR109 - Zero parameter call to vararg function: "
23052 + vararg_function_name +
" not allowed",
23055 return error_node();
23065 return error_node();
23067 arg_list.push_back(arg);
23069 if (token_is(token_t::e_rbracket))
23071 else if (!token_is(token_t::e_comma))
23076 "ERR110 - Expected ',' for call to vararg function: "
23077 + vararg_function_name,
23080 return error_node();
23090 "ERR111 - Zero parameter call to vararg function: "
23091 + vararg_function_name +
" not allowed",
23094 return error_node();
23097 if (arg_list.size() < vararg_function->
min_num_args())
23102 "ERR112 - Invalid number of parameters to call to vararg function: "
23103 + vararg_function_name +
", require at least "
23107 return error_node();
23109 else if (arg_list.size() > vararg_function->
max_num_args())
23114 "ERR113 - Invalid number of parameters to call to vararg function: "
23115 + vararg_function_name +
", require no more than "
23119 return error_node();
23122 result = expression_generator_.vararg_function_call(vararg_function,arg_list);
23137 const std::string& func_name,
23138 const std::string& param_seq)
23139 : invalid_state_(true),
23141 function_name_(func_name)
23146 bool verify(
const std::string& param_seq, std::size_t& pseq_index)
23148 if (param_seq_list_.empty())
23151 std::vector<std::pair<std::size_t,char> > error_list;
23153 for (std::size_t i = 0; i < param_seq_list_.size(); ++i)
23156 std::size_t diff_index = 0;
23160 diff_index,diff_value);
23168 error_list.push_back(std::make_pair(diff_index,diff_value));
23171 if (1 == error_list.size())
23176 parser_.current_token(),
23177 "ERR114 - Failed parameter type check for function '" + function_name_ +
"', "
23178 "Expected '" + param_seq_list_[0] +
"' call set: '" + param_seq +
"'",
23184 std::size_t max_diff_index = 0;
23186 for (std::size_t i = 1; i < error_list.size(); ++i)
23188 if (error_list[i].first > error_list[max_diff_index].first)
23190 max_diff_index = i;
23197 parser_.current_token(),
23198 "ERR115 - Failed parameter type check for function '" + function_name_ +
"', "
23199 "Best match: '" + param_seq_list_[max_diff_index] +
"' call set: '" + param_seq +
"'",
23208 return param_seq_list_.size();
23213 return param_seq_list_[index];
23218 return !invalid_state_;
23224 param_seq_list_.end() != std::find(param_seq_list_.begin(),
23225 param_seq_list_.end(),
23236 std::size_t
start = 0;
23237 std::size_t end = 0;
23241 struct token_validator
23243 static inline bool process(
const std::string& str,
23244 std::size_t s, std::size_t
e,
23249 (std::string::npos == str.find(
"?*")) &&
23250 (std::string::npos == str.find(
"**"))
23253 const std::string curr_str = str.substr(s, e - s);
23255 if (
"Z" == curr_str)
23257 psl.push_back(curr_str);
23260 else if (std::string::npos == curr_str.find_first_not_of(
"STV*?|"))
23262 psl.push_back(curr_str);
23271 while (std::string::npos != (end = s.find(
'|',start)))
23275 invalid_state_ =
false;
23277 const std::string err_param_seq = s.substr(start, end - start);
23282 parser_.current_token(),
23283 "ERR116 - Invalid parameter sequence of '" + err_param_seq +
23284 "' for function: " + function_name_,
23293 if (start < s.size())
23296 param_seq_list_ = param_seq_list;
23299 const std::string err_param_seq = s.substr(start, s.size() -
start);
23304 parser_.current_token(),
23305 "ERR117 - Invalid parameter sequence of '" + err_param_seq +
23306 "' for function: " + function_name_,
23324 std::vector<expression_node_ptr> arg_list;
23330 std::string param_type_list;
23332 type_checker tc((*
this), function_name, function->parameter_sequence);
23339 "ERR118 - Type checker instantiation failure for generic function: " + function_name,
23342 return error_node();
23346 !function->parameter_sequence.empty() &&
23347 function->allow_zero_parameters () &&
23354 "ERR119 - Mismatch in zero parameter condition for generic function: "
23358 return error_node();
23361 if (token_is(token_t::e_lbracket))
23363 if (token_is(token_t::e_rbracket))
23366 !function->allow_zero_parameters() &&
23373 "ERR120 - Zero parameter call to generic function: "
23374 + function_name +
" not allowed",
23377 return error_node();
23387 return error_node();
23390 param_type_list +=
'V';
23392 param_type_list +=
'S';
23394 param_type_list +=
'T';
23396 arg_list.push_back(arg);
23398 if (token_is(token_t::e_rbracket))
23400 else if (!token_is(token_t::e_comma))
23405 "ERR121 - Expected ',' for call to generic function: " + function_name,
23408 return error_node();
23414 !function->parameter_sequence.empty() &&
23415 function->allow_zero_parameters () &&
23422 "ERR122 - Zero parameter call to generic function: "
23423 + function_name +
" not allowed",
23426 return error_node();
23429 std::size_t param_seq_index = 0;
23432 state_.type_check_enabled &&
23433 !tc.
verify(param_type_list, param_seq_index)
23439 "ERR123 - Expected ',' for call to generic function: " + function_name,
23442 return error_node();
23448 result = expression_generator_
23449 .generic_function_call(
function, arg_list);
23451 result = expression_generator_
23452 .generic_function_call(
function, arg_list, param_seq_index);
23459 #ifndef exprtk_disable_string_capabilities
23462 std::vector<expression_node_ptr> arg_list;
23468 std::string param_type_list;
23470 type_checker tc((*
this), function_name, function->parameter_sequence);
23473 (!function->parameter_sequence.empty()) &&
23477 return error_node();
23480 if (token_is(token_t::e_lbracket))
23482 if (!token_is(token_t::e_rbracket))
23489 return error_node();
23492 param_type_list +=
'V';
23494 param_type_list +=
'S';
23496 param_type_list +=
'T';
23498 arg_list.push_back(arg);
23500 if (token_is(token_t::e_rbracket))
23502 else if (!token_is(token_t::e_comma))
23507 "ERR124 - Expected ',' for call to string function: " + function_name,
23510 return error_node();
23516 std::size_t param_seq_index = 0;
23518 if (!tc.
verify(param_type_list, param_seq_index))
23523 "ERR125 - Expected ',' for call to string function: " + function_name,
23526 return error_node();
23532 result = expression_generator_
23533 .string_function_call(
function, arg_list);
23535 result = expression_generator_
23536 .string_function_call(
function, arg_list, param_seq_index);
23544 template <
typename Type, std::
size_t NumberOfParameters>
23552 std::fill_n(branch,NumberOfParameters,reinterpret_cast<expression_node_ptr>(0));
23558 if (!p.token_is(token_t::e_lbracket))
23563 "ERR126 - Expected '(' for special function '" + sf_name +
"'",
23566 return error_node();
23569 for (std::size_t i = 0; i < NumberOfParameters; ++i)
23571 branch[i] = p.parse_expression();
23573 if (0 == branch[i])
23575 return p.error_node();
23577 else if (i < (NumberOfParameters - 1))
23579 if (!p.token_is(token_t::e_comma))
23584 "ERR127 - Expected ',' before next parameter of special function '" + sf_name +
"'",
23587 return p.error_node();
23592 if (!p.token_is(token_t::e_rbracket))
23597 "ERR128 - Invalid number of parameters for special function '" + sf_name +
"'",
23600 return p.error_node();
23603 result = p.expression_generator_.special_function(opt_type,branch);
23613 const std::string sf_name = current_token().
value;
23624 "ERR129 - Invalid special function[1]: " + sf_name,
23627 return error_node();
23630 const int id = (sf_name[2] -
'0') * 10 +
23631 (sf_name[3] -
'0');
23638 "ERR130 - Invalid special function[2]: " + sf_name,
23641 return error_node();
23646 const std::size_t NumberOfParameters = (
id < (sf_3_to_4 - 1000)) ? 3U : 4U;
23648 switch (NumberOfParameters)
23652 default :
return error_node();
23662 #ifndef exprtk_disable_break_continue
23665 if (state_.parsing_break_stmt)
23670 "ERR131 - Break call within a break call is not allowed",
23673 return error_node();
23678 if (!brkcnt_list_.empty())
23682 brkcnt_list_.front() =
true;
23686 if (token_is(token_t::e_lsqrbracket))
23688 if (0 == (return_expr = parse_expression()))
23693 "ERR132 - Failed to parse return expression for 'break' statement",
23696 return error_node();
23698 else if (!token_is(token_t::e_rsqrbracket))
23703 "ERR133 - Expected ']' at the completion of break's return expression",
23706 free_node(node_allocator_,return_expr);
23708 return error_node();
23712 state_.activate_side_effect(
"parse_break_statement()");
23721 "ERR134 - Invalid use of 'break', allowed only in the scope of a loop",
23725 return error_node();
23730 if (!brkcnt_list_.empty())
23734 brkcnt_list_.front() =
true;
23735 state_.activate_side_effect(
"parse_continue_statement()");
23744 "ERR135 - Invalid use of 'continue', allowed only in the scope of a loop",
23747 return error_node();
23756 if (!token_is(token_t::e_lsqrbracket))
23761 "ERR136 - Expected '[' as part of vector size definition",
23764 return error_node();
23766 else if (0 == (size_expr = parse_expression()))
23771 "ERR137 - Failed to determine size of vector '" + vec_name +
"'",
23774 return error_node();
23783 "ERR138 - Expected a literal number as size of vector '" + vec_name +
"'",
23786 return error_node();
23789 T vector_size = size_expr->
value();
23794 (vector_size <= T(0)) ||
23795 std::not_equal_to<T>()
23796 (T(0),vector_size - details::numeric::trunc(vector_size))
23802 "ERR139 - Invalid vector size. Must be an integer greater than zero, size: " +
23806 return error_node();
23809 std::vector<expression_node_ptr> vec_initilizer_list;
23813 bool single_value_initialiser =
false;
23814 bool vec_to_vec_initialiser =
false;
23815 bool null_initialisation =
false;
23817 if (!token_is(token_t::e_rsqrbracket))
23822 "ERR140 - Expected ']' as part of vector size definition",
23825 return error_node();
23827 else if (!token_is(token_t::e_eof))
23834 "ERR141 - Expected ':=' as part of vector definition",
23837 return error_node();
23839 else if (token_is(token_t::e_lsqrbracket))
23843 if (0 == initialiser)
23848 "ERR142 - Failed to parse single vector initialiser",
23851 return error_node();
23854 vec_initilizer_list.push_back(initialiser);
23856 if (!token_is(token_t::e_rsqrbracket))
23861 "ERR143 - Expected ']' to close single value vector initialiser",
23864 return error_node();
23867 single_value_initialiser =
true;
23869 else if (!token_is(token_t::e_lcrlbracket))
23874 if (token_t::e_symbol == current_token().
type)
23879 if (scope_element::e_vector == se.
type)
23881 if (0 != (initialiser = parse_expression()))
23882 vec_initilizer_list.push_back(initialiser);
23884 return error_node();
23887 else if (symtab_store_.is_vector(current_token().
value))
23889 lodge_symbol(current_token().
value,e_st_vector);
23891 if (0 != (initialiser = parse_expression()))
23892 vec_initilizer_list.push_back(initialiser);
23894 return error_node();
23897 else if (token_is(token_t::e_symbol,
"null"))
23898 null_initialisation =
true;
23901 if (!null_initialisation)
23903 if (0 == initialiser)
23908 "ERR144 - Expected '{' as part of vector initialiser list",
23911 return error_node();
23914 vec_to_vec_initialiser =
true;
23917 else if (!token_is(token_t::e_rcrlbracket))
23923 if (0 == initialiser)
23928 "ERR145 - Expected '{' as part of vector initialiser list",
23931 return error_node();
23934 vec_initilizer_list.push_back(initialiser);
23936 if (token_is(token_t::e_rcrlbracket))
23939 bool is_next_close = peek_token_is(token_t::e_rcrlbracket);
23941 if (!token_is(token_t::e_comma) && is_next_close)
23946 "ERR146 - Expected ',' between vector initialisers",
23949 return error_node();
23952 if (token_is(token_t::e_rcrlbracket))
23958 !token_is(token_t::e_rbracket ,prsrhlpr_t::e_hold) &&
23959 !token_is(token_t::e_rcrlbracket,prsrhlpr_t::e_hold) &&
23960 !token_is(token_t::e_rsqrbracket,prsrhlpr_t::e_hold)
23963 if (!token_is(token_t::e_eof))
23968 "ERR147 - Expected ';' at end of vector definition",
23971 return error_node();
23975 if (vec_initilizer_list.size() > vector_size)
23980 "ERR148 - Initialiser list larger than the number of elements in the vector: '" + vec_name +
"'",
23983 return error_node();
23993 if (se.
name == vec_name)
24000 "ERR149 - Illegal redefinition of local vector: '" + vec_name +
"'",
24003 return error_node();
24006 (se.
size == vec_size) &&
24007 (scope_element::e_vector == se.
type)
24012 se.
depth = state_.scope_depth;
24017 if (0 == vec_holder)
24020 nse.
name = vec_name;
24023 nse.
type = scope_element::e_vector;
24024 nse.
depth = state_.scope_depth;
24025 nse.
size = vec_size;
24026 nse.
data =
new T[vec_size];
24029 if (!sem_.add_element(nse))
24034 "ERR150 - Failed to add new local vector '" + vec_name +
"' to SEM",
24037 sem_.free_element(nse);
24039 return error_node();
24044 exprtk_debug((
"parse_define_vector_statement() - INFO - Added new local vector: %s[%d]\n",
24046 static_cast<int>(nse.
size)));
24049 state_.activate_side_effect(
"parse_define_vector_statement()");
24051 lodge_symbol(vec_name,e_st_local_vector);
24055 if (null_initialisation)
24056 result = expression_generator_(T(0.0));
24057 else if (vec_to_vec_initialiser)
24058 result = expression_generator_(
24061 vec_initilizer_list[0]);
24063 result = node_allocator_
24067 vec_initilizer_list,
24068 single_value_initialiser);
24075 #ifndef exprtk_disable_string_capabilities
24082 if (se.
name == str_name)
24089 "ERR151 - Illegal redefinition of local variable: '" + str_name +
"'",
24092 free_node(node_allocator_,initialisation_expression);
24094 return error_node();
24096 else if (scope_element::e_string == se.
type)
24100 se.
depth = state_.scope_depth;
24108 nse.
name = str_name;
24111 nse.
type = scope_element::e_string;
24112 nse.
depth = state_.scope_depth;
24113 nse.
data =
new std::string;
24116 if (!sem_.add_element(nse))
24121 "ERR152 - Failed to add new local string variable '" + str_name +
"' to SEM",
24124 free_node(node_allocator_,initialisation_expression);
24126 sem_.free_element(nse);
24128 return error_node();
24133 exprtk_debug((
"parse_define_string_statement() - INFO - Added new local string variable: %s\n",nse.
name.c_str()));
24136 lodge_symbol(str_name,e_st_local_string);
24138 state_.activate_side_effect(
"parse_define_string_statement()");
24142 branch[0] = str_node;
24143 branch[1] = initialisation_expression;
24148 inline expression_node_ptr parse_define_string_statement(
const std::string&, expression_node_ptr)
24150 return error_node();
24162 if (settings_.vardef_disabled())
24167 "ERR153 - Illegal variable definition",
24170 return error_node();
24174 return error_node();
24179 const std::string var_name = current_token().value;
24183 if (!token_is(token_t::e_symbol))
24188 "ERR154 - Expected a symbol for variable definition",
24191 return error_node();
24198 "ERR155 - Illegal redefinition of reserved keyword: '" + var_name +
"'",
24201 return error_node();
24203 else if (symtab_store_.symbol_exists(var_name))
24208 "ERR156 - Illegal redefinition of variable '" + var_name +
"'",
24211 return error_node();
24213 else if (local_variable_is_shadowed(var_name))
24218 "ERR157 - Illegal redefinition of local variable: '" + var_name +
"'",
24221 return error_node();
24223 else if (token_is(token_t::e_lsqrbracket,prsrhlpr_t::e_hold))
24225 return parse_define_vector_statement(var_name);
24227 else if (token_is(token_t::e_lcrlbracket,prsrhlpr_t::e_hold))
24229 return parse_uninitialised_var_statement(var_name);
24233 if (0 == (initialisation_expression = parse_expression()))
24238 "ERR158 - Failed to parse initialisation expression",
24241 return error_node();
24246 !token_is(token_t::e_rbracket ,prsrhlpr_t::e_hold) &&
24247 !token_is(token_t::e_rcrlbracket,prsrhlpr_t::e_hold) &&
24248 !token_is(token_t::e_rsqrbracket,prsrhlpr_t::e_hold)
24251 if (!token_is(token_t::e_eof,prsrhlpr_t::e_hold))
24256 "ERR159 - Expected ';' after variable definition",
24259 free_node(node_allocator_,initialisation_expression);
24261 return error_node();
24266 (0 != initialisation_expression) &&
24270 return parse_define_string_statement(var_name,initialisation_expression);
24277 if (se.
name == var_name)
24284 "ERR160 - Illegal redefinition of local variable: '" + var_name +
"'",
24287 free_node(node_allocator_, initialisation_expression);
24289 return error_node();
24291 else if (scope_element::e_variable == se.
type)
24295 se.
depth = state_.scope_depth;
24303 nse.
name = var_name;
24306 nse.
type = scope_element::e_variable;
24307 nse.
depth = state_.scope_depth;
24308 nse.
data =
new T(T(0));
24311 if (!sem_.add_element(nse))
24316 "ERR161 - Failed to add new local variable '" + var_name +
"' to SEM",
24319 free_node(node_allocator_, initialisation_expression);
24321 sem_.free_element(nse);
24323 return error_node();
24328 exprtk_debug((
"parse_define_var_statement() - INFO - Added new local variable: %s\n",nse.
name.c_str()));
24331 state_.activate_side_effect(
"parse_define_var_statement()");
24333 lodge_symbol(var_name,e_st_local_variable);
24337 branch[0] = var_node;
24338 branch[1] = initialisation_expression ? initialisation_expression : expression_generator_(T(0));
24346 !token_is(token_t::e_lcrlbracket) ||
24347 !token_is(token_t::e_rcrlbracket)
24353 "ERR162 - Expected a '{}' for uninitialised var definition",
24356 return error_node();
24358 else if (!token_is(token_t::e_eof,prsrhlpr_t::e_hold))
24363 "ERR163 - Expected ';' after uninitialised variable definition",
24366 return error_node();
24373 if (se.
name == var_name)
24380 "ERR164 - Illegal redefinition of local variable: '" + var_name +
"'",
24383 return error_node();
24385 else if (scope_element::e_variable == se.
type)
24396 nse.
name = var_name;
24399 nse.
type = scope_element::e_variable;
24400 nse.
depth = state_.scope_depth;
24401 nse.
ip_index = sem_.next_ip_index();
24402 nse.
data =
new T(T(0));
24405 if (!sem_.add_element(nse))
24410 "ERR165 - Failed to add new local variable '" + var_name +
"' to SEM",
24413 sem_.free_element(nse);
24415 return error_node();
24418 exprtk_debug((
"parse_uninitialised_var_statement() - INFO - Added new local variable: %s\n",
24419 nse.
name.c_str()));
24422 lodge_symbol(var_name,e_st_local_variable);
24424 state_.activate_side_effect(
"parse_uninitialised_var_statement()");
24426 return expression_generator_(T(0));
24433 return error_node();
24438 if (!token_is(token_t::e_lbracket))
24443 "ERR166 - Expected '(' at start of swap statement",
24446 return error_node();
24452 bool variable0_generated =
false;
24453 bool variable1_generated =
false;
24455 const std::string var0_name = current_token().value;
24457 if (!token_is(token_t::e_symbol,prsrhlpr_t::e_hold))
24462 "ERR167 - Expected a symbol for variable or vector element definition",
24465 return error_node();
24467 else if (peek_token_is(token_t::e_lsqrbracket))
24469 if (0 == (variable0 = parse_vector()))
24474 "ERR168 - First parameter to swap is an invalid vector element: '" + var0_name +
"'",
24477 return error_node();
24480 variable0_generated =
true;
24484 if (symtab_store_.is_variable(var0_name))
24486 variable0 = symtab_store_.get_variable(var0_name);
24493 (se.
name == var0_name) &&
24494 (scope_element::e_variable == se.
type)
24500 lodge_symbol(var0_name,e_st_variable);
24502 if (0 == variable0)
24507 "ERR169 - First parameter to swap is an invalid variable: '" + var0_name +
"'",
24510 return error_node();
24516 if (!token_is(token_t::e_comma))
24521 "ERR170 - Expected ',' between parameters to swap",
24524 if (variable0_generated)
24529 return error_node();
24532 const std::string var1_name = current_token().value;
24534 if (!token_is(token_t::e_symbol,prsrhlpr_t::e_hold))
24539 "ERR171 - Expected a symbol for variable or vector element definition",
24542 if (variable0_generated)
24547 return error_node();
24549 else if (peek_token_is(token_t::e_lsqrbracket))
24551 if (0 == (variable1 = parse_vector()))
24556 "ERR172 - Second parameter to swap is an invalid vector element: '" + var1_name +
"'",
24559 if (variable0_generated)
24564 return error_node();
24567 variable1_generated =
true;
24571 if (symtab_store_.is_variable(var1_name))
24573 variable1 = symtab_store_.get_variable(var1_name);
24580 (se.
name == var1_name) &&
24581 (scope_element::e_variable == se.
type)
24587 lodge_symbol(var1_name,e_st_variable);
24589 if (0 == variable1)
24594 "ERR173 - Second parameter to swap is an invalid variable: '" + var1_name +
"'",
24597 if (variable0_generated)
24602 return error_node();
24608 if (!token_is(token_t::e_rbracket))
24613 "ERR174 - Expected ')' at end of swap statement",
24616 if (variable0_generated)
24621 if (variable1_generated)
24626 return error_node();
24631 variable_node_ptr v0 = variable_node_ptr(0);
24632 variable_node_ptr v1 = variable_node_ptr(0);
24637 (0 != (v0 = dynamic_cast<variable_node_ptr>(variable0))) &&
24638 (0 != (v1 = dynamic_cast<variable_node_ptr>(variable1)))
24643 if (variable0_generated)
24648 if (variable1_generated)
24655 (variable0, variable1);
24657 state_.activate_side_effect(
"parse_swap_statement()");
24662 #ifndef exprtk_disable_return_statement
24665 if (state_.parsing_return_stmt)
24670 "ERR175 - Return call within a return call is not allowed",
24673 return error_node();
24678 std::vector<expression_node_ptr> arg_list;
24684 return error_node();
24689 if (!token_is(token_t::e_lsqrbracket))
24694 "ERR176 - Expected '[' at start of return statement",
24697 return error_node();
24699 else if (!token_is(token_t::e_rsqrbracket))
24706 return error_node();
24708 arg_list.push_back(arg);
24710 if (token_is(token_t::e_rsqrbracket))
24712 else if (!token_is(token_t::e_comma))
24717 "ERR177 - Expected ',' between values during call to return",
24720 return error_node();
24724 else if (settings_.zero_return_disabled())
24729 "ERR178 - Zero parameter return statement not allowed",
24732 return error_node();
24737 if (token_is(token_t::e_rsqrbracket))
24739 if (!arg_list.empty())
24744 "ERR179 - Invalid ']' found during return call",
24747 return error_node();
24751 std::string ret_param_type_list;
24753 for (std::size_t i = 0; i < arg_list.size(); ++i)
24755 if (0 == arg_list[i])
24756 return error_node();
24758 ret_param_type_list +=
'V';
24760 ret_param_type_list +=
'S';
24762 ret_param_type_list +=
'T';
24765 dec_.retparam_list_.push_back(ret_param_type_list);
24771 state_.return_stmt_present =
true;
24773 state_.activate_side_effect(
"parse_return_statement()");
24778 inline expression_node_ptr parse_return_statement()
24780 return error_node();
24787 peek_token_is(token_t::e_lbracket ) ||
24788 peek_token_is(token_t::e_lcrlbracket) ||
24789 peek_token_is(token_t::e_lsqrbracket)
24792 if (!settings_.commutative_check_enabled())
24797 "ERR180 - Invalid sequence of variable '"+ symbol +
"' and bracket",
24811 bool implied_mul =
false;
24820 case token_t::e_lcrlbracket : implied_mul = token_is(token_t::e_lbracket ,hold) ||
24821 token_is(token_t::e_lcrlbracket,hold) ||
24822 token_is(token_t::e_lsqrbracket,hold) ;
24825 case token_t::e_lbracket : implied_mul = token_is(token_t::e_lbracket ,hold) ||
24826 token_is(token_t::e_lcrlbracket,hold) ||
24827 token_is(token_t::e_lsqrbracket,hold) ;
24830 case token_t::e_lsqrbracket : implied_mul = token_is(token_t::e_lbracket ,hold) ||
24831 token_is(token_t::e_lcrlbracket,hold) ||
24832 token_is(token_t::e_lsqrbracket,hold) ;
24835 default :
return true;
24840 if (!settings_.commutative_check_enabled())
24845 "ERR181 - Invalid sequence of brackets",
24850 else if (token_t::e_eof != current_token().
type)
24852 lexer().insert_front(current_token().
type);
24863 const std::string symbol = current_token().
value;
24870 if (symtab_store_.is_constant_node(symbol))
24872 variable = expression_generator_(variable->
value());
24875 if (!post_variable_process(symbol))
24876 return error_node();
24878 lodge_symbol(symbol,e_st_variable);
24891 if (scope_element::e_variable == se.
type)
24894 lodge_symbol(symbol,e_st_local_variable);
24896 if (!post_variable_process(symbol))
24897 return error_node();
24903 else if (scope_element::e_vector == se.
type)
24905 return parse_vector();
24907 #ifndef exprtk_disable_string_capabilities
24908 else if (scope_element::e_string == se.
type)
24910 return parse_string();
24916 #ifndef exprtk_disable_string_capabilities
24918 if (symtab_store_.is_stringvar(symbol))
24920 return parse_string();
24926 ifunction<T>*
function = symtab_store_.get_function(symbol);
24930 lodge_symbol(symbol,e_st_function);
24933 parse_function_invocation(
function,symbol);
24942 "ERR182 - Failed to generate node for function: '" + symbol +
"'",
24945 return error_node();
24954 if (vararg_function)
24956 lodge_symbol(symbol,e_st_function);
24959 parse_vararg_function_call(vararg_function, symbol);
24961 if (vararg_func_node)
24962 return vararg_func_node;
24968 "ERR183 - Failed to generate node for vararg function: '" + symbol +
"'",
24971 return error_node();
24980 if (generic_function)
24982 lodge_symbol(symbol,e_st_function);
24985 parse_generic_function_call(generic_function, symbol);
24987 if (genericfunc_node)
24988 return genericfunc_node;
24994 "ERR184 - Failed to generate node for generic function: '" + symbol +
"'",
24997 return error_node();
25002 #ifndef exprtk_disable_string_capabilities
25007 if (string_function)
25009 lodge_symbol(symbol,e_st_function);
25012 parse_string_function_call(string_function, symbol);
25014 if (stringfunc_node)
25015 return stringfunc_node;
25021 "ERR185 - Failed to generate node for string function: '" + symbol +
"'",
25024 return error_node();
25031 if (symtab_store_.is_vector(symbol))
25033 lodge_symbol(symbol,e_st_vector);
25034 return parse_vector();
25040 settings_.function_enabled(symbol) ||
25047 "ERR186 - Invalid use of reserved symbol '" + symbol +
"'",
25050 return error_node();
25055 if (resolve_unknown_symbol_ && unknown_symbol_resolver_)
25061 std::string error_message;
25063 if (unknown_symbol_resolver::e_usrmode_default == unknown_symbol_resolver_->mode)
25065 T default_value = T(0);
25069 if (unknown_symbol_resolver_->process(symbol, usr_symbol_type, default_value, error_message))
25071 bool create_result =
false;
25073 switch (usr_symbol_type)
25075 case unknown_symbol_resolver::e_usr_variable_type : create_result = symtab.
create_variable(symbol, default_value);
25078 case unknown_symbol_resolver::e_usr_constant_type : create_result = symtab.
add_constant(symbol, default_value);
25081 default : create_result =
false;
25090 if (symtab_store_.is_constant_node(symbol))
25092 var = expression_generator_(var->
value());
25095 lodge_symbol(symbol,e_st_variable);
25097 if (!post_variable_process(symbol))
25098 return error_node();
25110 "ERR187 - Failed to create variable: '" + symbol +
"'" +
25111 (error_message.empty() ?
"" :
" - " + error_message),
25115 else if (unknown_symbol_resolver::e_usrmode_extended == unknown_symbol_resolver_->mode)
25117 if (unknown_symbol_resolver_->process(symbol, symtab, error_message))
25130 "ERR188 - Failed to resolve symbol: '" + symbol +
"'" +
25131 (error_message.empty() ?
"" :
" - " + error_message),
25135 return error_node();
25142 "ERR189 - Undefined symbol: '" + symbol +
"'",
25145 return error_node();
25150 static const std::string symbol_if =
"if" ;
25151 static const std::string symbol_while =
"while" ;
25152 static const std::string symbol_repeat =
"repeat" ;
25153 static const std::string symbol_for =
"for" ;
25154 static const std::string symbol_switch =
"switch" ;
25155 static const std::string symbol_null =
"null" ;
25156 static const std::string symbol_break =
"break" ;
25157 static const std::string symbol_continue =
"continue";
25158 static const std::string symbol_var =
"var" ;
25159 static const std::string symbol_swap =
"swap" ;
25160 static const std::string symbol_return =
"return" ;
25162 if (valid_vararg_operation(current_token().
value))
25164 return parse_vararg_function();
25166 else if (valid_base_operation(current_token().
value))
25168 return parse_base_operation();
25172 settings_.control_struct_enabled(current_token().
value)
25175 return parse_conditional_statement();
25179 settings_.control_struct_enabled(current_token().
value)
25182 return parse_while_loop();
25186 settings_.control_struct_enabled(current_token().
value)
25189 return parse_repeat_until_loop();
25193 settings_.control_struct_enabled(current_token().
value)
25196 return parse_for_loop();
25200 settings_.control_struct_enabled(current_token().
value)
25203 return parse_switch_statement();
25207 return parse_special_function();
25211 return parse_null_statement();
25213 #ifndef exprtk_disable_break_continue
25216 return parse_break_statement();
25220 return parse_continue_statement();
25225 return parse_define_var_statement();
25229 return parse_swap_statement();
25231 #ifndef exprtk_disable_return_statement
25234 settings_.control_struct_enabled(current_token().
value)
25237 return parse_return_statement();
25240 else if (symtab_store_.valid() || !sem_.empty())
25242 return parse_symtab_symbol();
25249 "ERR190 - Variable or function detected, yet symbol-table is invalid, Symbol: " + current_token().
value,
25252 return error_node();
25260 if (token_t::e_number == current_token().
type)
25262 T numeric_value = T(0);
25268 if (0 == literal_exp)
25273 "ERR191 - Failed generate node for scalar: '" + current_token().
value +
"'",
25276 return error_node();
25280 branch = literal_exp;
25287 "ERR192 - Failed to convert '" + current_token().
value +
"' to a number",
25290 return error_node();
25293 else if (token_t::e_symbol == current_token().
type)
25295 branch = parse_symbol();
25297 #ifndef exprtk_disable_string_capabilities
25298 else if (token_t::e_string == current_token().
type)
25300 branch = parse_const_string();
25303 else if (token_t::e_lbracket == current_token().
type)
25307 if (0 == (branch = parse_expression()))
25308 return error_node();
25309 else if (!token_is(token_t::e_rbracket))
25314 "ERR193 - Expected ')' instead of: '" + current_token().
value +
"'",
25319 return error_node();
25321 else if (!post_bracket_process(token_t::e_lbracket,branch))
25325 return error_node();
25328 else if (token_t::e_lsqrbracket == current_token().
type)
25332 if (0 == (branch = parse_expression()))
25333 return error_node();
25334 else if (!token_is(token_t::e_rsqrbracket))
25339 "ERR194 - Expected ']' instead of: '" + current_token().
value +
"'",
25344 return error_node();
25346 else if (!post_bracket_process(token_t::e_lsqrbracket,branch))
25350 return error_node();
25353 else if (token_t::e_lcrlbracket == current_token().
type)
25357 if (0 == (branch = parse_expression()))
25358 return error_node();
25359 else if (!token_is(token_t::e_rcrlbracket))
25364 "ERR195 - Expected '}' instead of: '" + current_token().
value +
"'",
25369 return error_node();
25371 else if (!post_bracket_process(token_t::e_lcrlbracket,branch))
25375 return error_node();
25381 branch = parse_expression(e_level11);
25387 simplify_unary_negation_branch(branch)
25397 branch = parse_expression(e_level13);
25399 else if (token_t::e_eof == current_token().
type)
25404 "ERR196 - Premature end of expression[1]",
25407 return error_node();
25414 "ERR197 - Premature end of expression[2]",
25417 return error_node();
25422 (e_level00 == precedence) &&
25423 token_is(token_t::e_ternary,prsrhlpr_t::e_hold)
25426 branch = parse_ternary_conditional_statement(branch);
25429 parse_pending_string_rangesize(branch);
25434 template <
typename Type>
25448 #ifndef exprtk_disable_enhanced_features
25453 #define register_synthezier(S) \
25454 synthesize_map_[S ::node_type::id()] = S ::process; \
25526 unary_op_map_ = &unary_op_map;
25531 binary_op_map_ = &binary_op_map;
25536 inv_binary_op_map_ = &inv_binary_op_map;
25541 sf3_map_ = &sf3_map;
25546 sf4_map_ = &sf4_map;
25551 node_allocator_ = &na;
25556 strength_reduction_enabled_ = enabled;
25561 return strength_reduction_enabled_;
25566 typename binary_op_map_t::iterator bop_itr = binary_op_map_->find(operation);
25568 if ((*binary_op_map_).end() == bop_itr)
25571 bop = bop_itr->second;
25578 typename unary_op_map_t::iterator uop_itr = unary_op_map_->find(operation);
25580 if ((*unary_op_map_).end() == uop_itr)
25583 uop = uop_itr->second;
25590 return (*inv_binary_op_map_).find(bop)->second;
25598 #ifndef exprtk_disable_string_capabilities
25619 return error_node();
25649 typename sf3_map_t::iterator itr = sf3_map_->find(sf3id);
25651 if (sf3_map_->end() == itr)
25654 tfunc = itr->second.first;
25661 typename sf4_map_t::iterator itr = sf4_map_->find(sf4id);
25663 if (sf4_map_->end() == itr)
25666 qfunc = itr->second.first;
25673 typename sf3_map_t::iterator itr = sf3_map_->find(sf3id);
25675 if (sf3_map_->end() == itr)
25678 operation = itr->second.second;
25685 typename sf4_map_t::iterator itr = sf4_map_->find(sf4id);
25687 if (sf4_map_->end() == itr)
25690 operation = itr->second.second;
25697 if (0 == branch[0])
25699 return error_node();
25707 return error_node();
25711 return error_node();
25715 return synthesize_expression<unary_node_t,1>(operation,branch);
25719 return synthesize_uv_expression(operation,branch);
25723 return synthesize_uvec_expression(operation,branch);
25726 return synthesize_unary_expression(operation,branch);
25738 parser_->settings_.assignment_enabled(operation);
25741 #ifndef exprtk_disable_string_capabilities
25787 default :
return "UNKNOWN";
25815 static const std::string null_str (
"(null)" );
25816 static const std::string const_str (
"(c)" );
25817 static const std::string var_str (
"(v)" );
25818 static const std::string vov_str (
"(vov)" );
25819 static const std::string cov_str (
"(cov)" );
25820 static const std::string voc_str (
"(voc)" );
25821 static const std::string str_str (
"(s)" );
25822 static const std::string strrng_str (
"(rngs)" );
25823 static const std::string cs_str (
"(cs)" );
25824 static const std::string cstrrng_str(
"(crngs)");
25845 return cstrrng_str;
25856 return branch_to_id(branch[0]) + std::string(
"o") + branch_to_id(branch[1]);
25861 if (!operation_optimisable(operation))
25870 if (!operation_optimisable(operation))
25879 if (!operation_optimisable(operation))
25888 if (!operation_optimisable(operation))
25897 if (!operation_optimisable(operation))
25938 if (!operation_optimisable(operation))
25947 if (!operation_optimisable(operation))
25956 if (!operation_optimisable(operation))
25965 if (!operation_optimisable(operation))
25974 if (is_assignment_operation(operation))
25979 return !b1_is_genstring;
25988 || b1_is_genstring;
26007 return cardinal_pow_optimisable(operation, c);
26025 bool result =
false;
26027 if (b0_string != b1_string)
26029 else if (!valid_string_operation(operation) && b0_string && b1_string)
26034 parser_->set_synthesis_error(
"Invalid string operation");
26046 bool result =
false;
26048 if ((b0_string != b1_string) || (b1_string != b2_string))
26055 parser_->set_synthesis_error(
"Invalid string operation");
26066 return (b0_string && b1_string && valid_string_operation(operation));
26078 #ifndef exprtk_disable_sc_andor
26139 if ((0 == branch[0]) || (0 == branch[1]))
26141 return error_node();
26143 else if (is_invalid_string_op(operation,branch))
26145 return error_node();
26147 else if (is_invalid_assignment_op(operation,branch))
26149 return error_node();
26151 else if (is_invalid_break_continue_op(branch))
26153 return error_node();
26157 return synthesize_assignment_expression(operation, branch);
26161 return synthesize_swap_expression(branch);
26163 else if (is_assignment_operation(operation))
26165 return synthesize_assignment_operation_expression(operation, branch);
26167 else if (is_vector_eqineq_logic_operation(operation, branch))
26169 return synthesize_veceqineqlogic_operation_expression(operation, branch);
26171 else if (is_vector_arithmetic_operation(operation, branch))
26173 return synthesize_vecarithmetic_operation_expression(operation, branch);
26175 else if (is_shortcircuit_expression(operation))
26177 return synthesize_shortcircuit_expression(operation, branch);
26179 else if (is_string_operation(operation, branch))
26181 return synthesize_string_expression(operation, branch);
26183 else if (is_null_present(branch))
26185 return synthesize_null_expression(operation, branch);
26187 #ifndef exprtk_disable_cardinal_pow_optimisation
26188 else if (is_constpow_operation(operation, branch))
26190 return cardinal_pow_optimisation(branch);
26196 #ifndef exprtk_disable_enhanced_features
26197 if (synthesize_expression(operation, branch, result))
26212 result = error_node();
26214 if (cocob_optimisable(operation, branch))
26218 else if (coboc_optimisable(operation, branch) && (0 == result))
26227 if (uvouv_optimisable(operation, branch))
26229 return synthesize_uvouv_expression(operation, branch);
26231 else if (vob_optimisable(operation, branch))
26235 else if (bov_optimisable(operation, branch))
26239 else if (cob_optimisable(operation, branch))
26243 else if (boc_optimisable(operation, branch))
26247 #ifndef exprtk_disable_enhanced_features
26248 else if (cov_optimisable(operation, branch))
26253 else if (binext_optimisable(operation, branch))
26258 return synthesize_expression<binary_node_t,2>(operation, branch);
26264 (0 == branch[0]) ||
26265 (0 == branch[1]) ||
26271 return error_node();
26273 else if (is_invalid_string_op(operation, branch))
26275 return error_node();
26277 else if (is_string_operation(operation, branch))
26279 return synthesize_string_expression(operation, branch);
26282 return synthesize_expression<trinary_node_t,3>(operation, branch);
26287 return synthesize_expression<quaternary_node_t,4>(operation,branch);
26293 return (*
this)(operation,branch);
26298 if ((0 == b0) || (0 == b1))
26299 return error_node();
26311 if ((0 == condition) || (0 == consequent))
26313 free_node(*node_allocator_, condition);
26314 free_node(*node_allocator_, consequent);
26315 free_node(*node_allocator_, alternative);
26317 return error_node();
26325 free_node(*node_allocator_, condition);
26326 free_node(*node_allocator_, alternative);
26333 free_node(*node_allocator_, condition);
26334 free_node(*node_allocator_, consequent);
26337 return alternative;
26342 else if ((0 != consequent) && (0 != alternative))
26344 return node_allocator_->
26345 allocate<conditional_node_t>(condition, consequent, alternative);
26348 return node_allocator_->
26349 allocate<cons_conditional_node_t>(condition, consequent);
26352 #ifndef exprtk_disable_string_capabilities
26357 if ((0 == condition) || (0 == consequent))
26359 free_node(*node_allocator_, condition);
26360 free_node(*node_allocator_, consequent);
26361 free_node(*node_allocator_, alternative);
26363 return error_node();
26371 free_node(*node_allocator_, condition);
26372 free_node(*node_allocator_, alternative);
26379 free_node(*node_allocator_, condition);
26380 free_node(*node_allocator_, consequent);
26383 return alternative;
26385 return node_allocator_->
26386 allocate_c<details::string_literal_node<Type> >(
"");
26389 else if ((0 != consequent) && (0 != alternative))
26390 return node_allocator_->
26391 allocate<conditional_string_node_t>(condition, consequent, alternative);
26393 return error_node();
26400 return error_node();
26406 const bool brkcont =
false)
const
26413 result = error_node();
26417 free_node(*node_allocator_, condition);
26430 #ifndef exprtk_disable_break_continue
26434 return error_node();
26440 const bool brkcont =
false)
const
26454 free_node(*node_allocator_, condition);
26457 return error_node();
26467 #ifndef exprtk_disable_break_continue
26471 return error_node();
26479 bool brkcont =
false)
const
26487 result = error_node();
26491 free_node(*node_allocator_, initialiser);
26492 free_node(*node_allocator_, condition);
26493 free_node(*node_allocator_, incrementor);
26494 free_node(*node_allocator_, loop_body);
26500 free_node(*node_allocator_, initialiser);
26501 free_node(*node_allocator_, condition);
26502 free_node(*node_allocator_, incrementor);
26515 #ifndef exprtk_disable_break_continue
26525 return error_node();
26529 template <
typename Allocator,
26530 template <
typename,
typename>
class Sequence>
26535 for (std::size_t i = 0; i < (arg_list.size() / 2); ++i)
26542 result = consequent;
26549 result = arg_list.back();
26552 for (std::size_t i = 0; i < arg_list.size(); ++i)
26556 if (current_expr && (current_expr != result))
26558 free_node(*node_allocator_,current_expr);
26565 template <
typename Allocator,
26566 template <
typename,
typename>
class Sequence>
26571 for (std::size_t i = 0; i < (arg_list.size() / 2); ++i)
26578 result = consequent;
26588 for (std::size_t i = 0; i < arg_list.size(); ++i)
26592 if (current_expr && (current_expr != result))
26594 free_node(*node_allocator_,current_expr);
26605 #define case_stmt(N) \
26606 if (is_true(arg[(2 * N)])) { return arg[(2 * N) + 1]->value(); } \
26614 return arg.back()->value();
26624 return arg.back()->value();
26635 return arg.back()->value();
26646 return arg.back()->value();
26658 return arg.back()->value();
26670 return arg.back()->value();
26683 return arg.back()->value();
26690 template <
typename Allocator,
26691 template <
typename,
typename>
class Sequence>
26694 if (arg_list.empty())
26695 return error_node();
26698 (arg_list.size() < 3) ||
26699 ((arg_list.size() % 2) != 1)
26704 return error_node();
26706 else if (is_constant_foldable(arg_list))
26707 return const_optimise_switch(arg_list);
26709 switch ((arg_list.size() - 1) / 2)
26711 #define case_stmt(N) \
26713 return node_allocator_-> \
26714 allocate<details::switch_n_node \
26715 <Type,typename switch_nodes::switch_##N> >(arg_list); \
26730 template <
typename Allocator,
26731 template <
typename,
typename>
class Sequence>
26738 return error_node();
26740 else if (is_constant_foldable(arg_list))
26741 return const_optimise_mswitch(arg_list);
26746 #define unary_opr_switch_statements \
26747 case_stmt(details:: e_abs, details:: abs_op) \
26748 case_stmt(details:: e_acos, details:: acos_op) \
26749 case_stmt(details::e_acosh, details::acosh_op) \
26750 case_stmt(details:: e_asin, details:: asin_op) \
26751 case_stmt(details::e_asinh, details::asinh_op) \
26752 case_stmt(details:: e_atan, details:: atan_op) \
26753 case_stmt(details::e_atanh, details::atanh_op) \
26754 case_stmt(details:: e_ceil, details:: ceil_op) \
26755 case_stmt(details:: e_cos, details:: cos_op) \
26756 case_stmt(details:: e_cosh, details:: cosh_op) \
26757 case_stmt(details:: e_exp, details:: exp_op) \
26758 case_stmt(details::e_expm1, details::expm1_op) \
26759 case_stmt(details::e_floor, details::floor_op) \
26760 case_stmt(details:: e_log, details:: log_op) \
26761 case_stmt(details::e_log10, details::log10_op) \
26762 case_stmt(details:: e_log2, details:: log2_op) \
26763 case_stmt(details::e_log1p, details::log1p_op) \
26764 case_stmt(details:: e_neg, details:: neg_op) \
26765 case_stmt(details:: e_pos, details:: pos_op) \
26766 case_stmt(details::e_round, details::round_op) \
26767 case_stmt(details:: e_sin, details:: sin_op) \
26768 case_stmt(details:: e_sinc, details:: sinc_op) \
26769 case_stmt(details:: e_sinh, details:: sinh_op) \
26770 case_stmt(details:: e_sqrt, details:: sqrt_op) \
26771 case_stmt(details:: e_tan, details:: tan_op) \
26772 case_stmt(details:: e_tanh, details:: tanh_op) \
26773 case_stmt(details:: e_cot, details:: cot_op) \
26774 case_stmt(details:: e_sec, details:: sec_op) \
26775 case_stmt(details:: e_csc, details:: csc_op) \
26776 case_stmt(details:: e_r2d, details:: r2d_op) \
26777 case_stmt(details:: e_d2r, details:: d2r_op) \
26778 case_stmt(details:: e_d2g, details:: d2g_op) \
26779 case_stmt(details:: e_g2d, details:: g2d_op) \
26780 case_stmt(details:: e_notl, details:: notl_op) \
26781 case_stmt(details:: e_sgn, details:: sgn_op) \
26782 case_stmt(details:: e_erf, details:: erf_op) \
26783 case_stmt(details:: e_erfc, details:: erfc_op) \
26784 case_stmt(details:: e_ncdf, details:: ncdf_op) \
26785 case_stmt(details:: e_frac, details:: frac_op) \
26786 case_stmt(details::e_trunc, details::trunc_op) \
26795 #define case_stmt(op0,op1) \
26796 case op0 : return node_allocator_-> \
26797 allocate<typename details::unary_variable_node<Type,op1<Type> > >(v); \
26801 default :
return error_node();
26810 #define case_stmt(op0,op1) \
26811 case op0 : return node_allocator_-> \
26812 allocate<typename details::unary_vector_node<Type,op1<Type> > > \
26813 (operation, branch[0]); \
26817 default :
return error_node();
26826 #define case_stmt(op0,op1) \
26827 case op0 : return node_allocator_-> \
26828 allocate<typename details::unary_branch_node<Type,op1<Type> > >(branch[0]); \
26832 default :
return error_node();
26843 #define case_stmt(op) \
26844 case details::e_sf##op : temp_node = node_allocator_-> \
26845 allocate<details::sf3_node<Type,details::sf##op##_op<Type> > > \
26846 (operation, branch); \
26862 default :
return error_node();
26865 const T
v = temp_node->
value();
26876 const Type& v0 =
static_cast<variable_ptr
>(branch[0])->ref();
26877 const Type& v1 =
static_cast<variable_ptr
>(branch[1])->ref();
26878 const Type& v2 =
static_cast<variable_ptr
>(branch[2])->ref();
26882 #define case_stmt(op) \
26883 case details::e_sf##op : return node_allocator_-> \
26884 allocate_rrr<details::sf3_var_node<Type,details::sf##op##_op<Type> > > \
26900 default :
return error_node();
26907 return error_node();
26908 else if (is_constant_foldable(branch))
26909 return const_optimise_sf3(operation,branch);
26911 return varnode_optimise_sf3(operation,branch);
26916 #define case_stmt(op) \
26917 case details::e_sf##op : return node_allocator_-> \
26918 allocate<details::sf3_node<Type,details::sf##op##_op<Type> > > \
26919 (operation, branch); \
26934 default :
return error_node();
26945 #define case_stmt(op) \
26946 case details::e_sf##op : temp_node = node_allocator_-> \
26947 allocate<details::sf4_node<Type,details::sf##op##_op<Type> > > \
26948 (operation, branch); \
26965 default :
return error_node();
26968 const T
v = temp_node->
value();
26979 const Type& v0 =
static_cast<variable_ptr
>(branch[0])->ref();
26980 const Type& v1 =
static_cast<variable_ptr
>(branch[1])->ref();
26981 const Type& v2 =
static_cast<variable_ptr
>(branch[2])->ref();
26982 const Type& v3 =
static_cast<variable_ptr
>(branch[3])->ref();
26986 #define case_stmt(op) \
26987 case details::e_sf##op : return node_allocator_-> \
26988 allocate_rrrr<details::sf4_var_node<Type,details::sf##op##_op<Type> > > \
26989 (v0, v1, v2, v3); \
27005 default :
return error_node();
27012 return error_node();
27013 else if (is_constant_foldable(branch))
27014 return const_optimise_sf4(operation,branch);
27016 return varnode_optimise_sf4(operation,branch);
27019 #define case_stmt(op) \
27020 case details::e_sf##op : return node_allocator_-> \
27021 allocate<details::sf4_node<Type,details::sf##op##_op<Type> > > \
27022 (operation, branch); \
27038 default :
return error_node();
27042 template <
typename Allocator,
27043 template <
typename,
typename>
class Sequence>
27050 #define case_stmt(op0,op1) \
27051 case op0 : temp_node = node_allocator_-> \
27052 allocate<details::vararg_node<Type,op1<Type> > > \
27065 default :
return error_node();
27068 const T
v = temp_node->
value();
27086 template <
typename Allocator,
27087 template <
typename,
typename>
class Sequence>
27092 #define case_stmt(op0,op1) \
27093 case op0 : return node_allocator_-> \
27094 allocate<details::vararg_varnode<Type,op1<Type> > >(arg_list); \
27105 default :
return error_node();
27109 template <
typename Allocator,
27110 template <
typename,
typename>
class Sequence>
27113 if (1 == arg_list.size())
27117 #define case_stmt(op0,op1) \
27118 case op0 : return node_allocator_-> \
27119 allocate<details::vectorize_node<Type,op1<Type> > >(arg_list[0]); \
27127 default :
return error_node();
27131 return error_node();
27134 template <
typename Allocator,
27135 template <
typename,
typename>
class Sequence>
27142 return error_node();
27144 else if (is_constant_foldable(arg_list))
27145 return const_optimise_varargfunc(operation,arg_list);
27147 return vectorize_func(operation,arg_list);
27148 else if ((arg_list.size() == 1) && special_one_parameter_vararg(operation))
27149 return arg_list[0];
27151 return varnode_optimise_varargfunc(operation,arg_list);
27153 #ifndef exprtk_disable_string_capabilities
27156 return node_allocator_->
27157 allocate<details::str_vararg_node<Type,details::vararg_multi_op<Type> > >(arg_list);
27164 #define case_stmt(op0,op1) \
27165 case op0 : return node_allocator_-> \
27166 allocate<details::vararg_node<Type,op1<Type> > >(arg_list); \
27177 default :
return error_node();
27182 template <std::
size_t N>
27189 return error_node();
27196 return error_node();
27197 else if (N != f->param_count)
27201 return error_node();
27204 function_N_node_t* func_node_ptr =
static_cast<function_N_node_t*
>(result);
27206 if (func_node_ptr->init_branches(b))
27212 return error_node();
27220 return node_allocator_->allocate<function_N_node_t>(f);
27224 std::vector<expression_node_ptr>& arg_list)
27230 return error_node();
27238 !arg_list.empty() &&
27239 !vaf->has_side_effects() &&
27240 is_constant_foldable(arg_list)
27243 const Type
v = result->
value();
27248 parser_->state_.activate_side_effect(
"vararg_function_call()");
27254 std::vector<expression_node_ptr>& arg_list,
27260 return error_node();
27270 if (no_psi == param_seq_index)
27271 result = node_allocator_->allocate<alloc_type1>(arg_list,gf);
27273 result = node_allocator_->allocate<alloc_type2>(gf, param_seq_index, arg_list);
27275 alloc_type1* genfunc_node_ptr =
static_cast<alloc_type1*
>(result);
27278 !arg_list.empty() &&
27279 !gf->has_side_effects() &&
27280 parser_->state_.type_check_enabled &&
27281 is_constant_foldable(arg_list)
27284 genfunc_node_ptr->init_branches();
27286 const Type
v = result->value();
27292 else if (genfunc_node_ptr->init_branches())
27294 parser_->state_.activate_side_effect(
"generic_function_call()");
27303 return error_node();
27307 #ifndef exprtk_disable_string_capabilities
27309 std::vector<expression_node_ptr>& arg_list,
27315 return error_node();
27325 if (no_psi == param_seq_index)
27326 result = node_allocator_->allocate<alloc_type1>(gf,arg_list);
27328 result = node_allocator_->allocate<alloc_type2>(gf, param_seq_index, arg_list);
27330 alloc_type1* strfunc_node_ptr =
static_cast<alloc_type1*
>(result);
27333 !arg_list.empty() &&
27334 !gf->has_side_effects() &&
27335 is_constant_foldable(arg_list)
27338 strfunc_node_ptr->init_branches();
27340 const Type
v = result->value();
27346 else if (strfunc_node_ptr->init_branches())
27348 parser_->state_.activate_side_effect(
"string_function_call()");
27357 return error_node();
27362 #ifndef exprtk_disable_return_statement
27368 return error_node();
27374 allocate_rr<alloc_type>(arg_list,parser_->results_ctx());
27376 alloc_type* return_node_ptr =
static_cast<alloc_type*
>(result);
27378 if (return_node_ptr->init_branches())
27380 parser_->state_.activate_side_effect(
"return_call()");
27389 return error_node();
27395 bool*& return_invoked)
27400 allocate_cr<alloc_type>(body,(*rc));
27402 return_invoked =
static_cast<alloc_type*
>(result)->retinvk_ptr();
27409 return error_node();
27412 inline expression_node_ptr return_envelope(expression_node_ptr,
27413 results_context_t*,
27416 return error_node();
27421 vector_holder_ptr vector_base,
27449 nse.
type = scope_element::e_vecelem;
27451 nse.
depth = parser_->state_.scope_depth;
27455 if (!parser_->sem_.add_element(nse))
27457 parser_->set_synthesis_error(
"Failed to add new local vector element to SEM [1]");
27459 parser_->sem_.free_element(nse);
27461 result = error_node();
27464 exprtk_debug((
"vector_element() - INFO - Added new local vector element: %s\n",nse.
name.c_str()));
27466 parser_->state_.activate_side_effect(
"vector_element()");
27481 template <std::
size_t N,
typename NodePtr>
27484 for (std::size_t i = 0; i < N; ++i)
27495 template <
typename NodePtr,
27496 typename Allocator,
27497 template <
typename,
typename>
class Sequence>
27500 for (std::size_t i = 0; i < b.size(); ++i)
27513 parser_->state_.activate_side_effect(
"lodge_assignment()");
27515 if (!parser_->dec_.collect_assignments())
27518 std::string symbol_name;
27522 case e_st_variable : symbol_name = parser_->symtab_store_
27523 .get_variable_name(node);
27526 #ifndef exprtk_disable_string_capabilities
27527 case e_st_string : symbol_name = parser_->symtab_store_
27528 .get_stringvar_name(node);
27532 case e_st_vector : {
27535 vector_holder_t& vh =
static_cast<vector_node_t*
>(node)->vec_holder();
27537 symbol_name = parser_->symtab_store_.get_vector_name(&vh);
27541 case e_st_vecelem : {
27546 symbol_name = parser_->symtab_store_.get_vector_name(&vh);
27555 if (!symbol_name.empty())
27557 parser_->dec_.add_assignment(symbol_name,cst);
27565 lodge_assignment(e_st_variable,branch[0]);
27567 return synthesize_expression<assignment_node_t,2>(operation,branch);
27571 lodge_assignment(e_st_vecelem,branch[0]);
27573 return synthesize_expression<assignment_vec_elem_node_t, 2>(operation, branch);
27577 lodge_assignment(e_st_vecelem,branch[0]);
27579 return synthesize_expression<assignment_rebasevec_elem_node_t, 2>(operation, branch);
27583 lodge_assignment(e_st_vecelem,branch[0]);
27585 return synthesize_expression<assignment_rebasevec_celem_node_t, 2>(operation, branch);
27587 #ifndef exprtk_disable_string_capabilities
27590 lodge_assignment(e_st_string,branch[0]);
27592 return synthesize_expression<assignment_string_node_t,2>(operation, branch);
27596 lodge_assignment(e_st_string,branch[0]);
27598 return synthesize_expression<assignment_string_range_node_t,2>(operation, branch);
27603 lodge_assignment(e_st_vector,branch[0]);
27606 return synthesize_expression<assignment_vecvec_node_t,2>(operation, branch);
27608 return synthesize_expression<assignment_vec_node_t,2>(operation, branch);
27612 parser_->set_synthesis_error(
"Invalid assignment operation.[1]");
27614 return error_node();
27623 lodge_assignment(e_st_variable,branch[0]);
27627 #define case_stmt(op0,op1) \
27628 case op0 : return node_allocator_-> \
27629 template allocate_rrr<typename details::assignment_op_node<Type,op1<Type> > > \
27630 (operation, branch[0], branch[1]); \
27638 default :
return error_node();
27643 lodge_assignment(e_st_vecelem,branch[0]);
27647 #define case_stmt(op0,op1) \
27648 case op0 : return node_allocator_-> \
27649 template allocate_rrr<typename details::assignment_vec_elem_op_node<Type,op1<Type> > > \
27650 (operation, branch[0], branch[1]); \
27658 default :
return error_node();
27663 lodge_assignment(e_st_vecelem,branch[0]);
27667 #define case_stmt(op0,op1) \
27668 case op0 : return node_allocator_-> \
27669 template allocate_rrr<typename details::assignment_rebasevec_elem_op_node<Type,op1<Type> > > \
27670 (operation, branch[0], branch[1]); \
27678 default :
return error_node();
27683 lodge_assignment(e_st_vecelem,branch[0]);
27687 #define case_stmt(op0,op1) \
27688 case op0 : return node_allocator_-> \
27689 template allocate_rrr<typename details::assignment_rebasevec_celem_op_node<Type,op1<Type> > > \
27690 (operation, branch[0], branch[1]); \
27698 default :
return error_node();
27703 lodge_assignment(e_st_vector,branch[0]);
27709 #define case_stmt(op0,op1) \
27710 case op0 : return node_allocator_-> \
27711 template allocate_rrr<typename details::assignment_vecvec_op_node<Type,op1<Type> > > \
27712 (operation, branch[0], branch[1]); \
27720 default :
return error_node();
27727 #define case_stmt(op0,op1) \
27728 case op0 : return node_allocator_-> \
27729 template allocate_rrr<typename details::assignment_vec_op_node<Type,op1<Type> > > \
27730 (operation, branch[0], branch[1]); \
27738 default :
return error_node();
27742 #ifndef exprtk_disable_string_capabilities
27750 lodge_assignment(e_st_string,branch[0]);
27752 return synthesize_expression<addass_t,2>(operation,branch);
27757 parser_->set_synthesis_error(
"Invalid assignment operation[2]");
27759 return error_node();
27769 #define batch_eqineq_logic_case \
27770 case_stmt(details:: e_lt, details:: lt_op) \
27771 case_stmt(details:: e_lte, details:: lte_op) \
27772 case_stmt(details:: e_gt, details:: gt_op) \
27773 case_stmt(details:: e_gte, details:: gte_op) \
27774 case_stmt(details:: e_eq, details:: eq_op) \
27775 case_stmt(details:: e_ne, details:: ne_op) \
27776 case_stmt(details::e_equal, details::equal_op) \
27777 case_stmt(details:: e_and, details:: and_op) \
27778 case_stmt(details:: e_nand, details:: nand_op) \
27779 case_stmt(details:: e_or, details:: or_op) \
27780 case_stmt(details:: e_nor, details:: nor_op) \
27781 case_stmt(details:: e_xor, details:: xor_op) \
27782 case_stmt(details:: e_xnor, details:: xnor_op) \
27784 if (is_b0_ivec && is_b1_ivec)
27788 #define case_stmt(op0,op1) \
27789 case op0 : return node_allocator_-> \
27790 template allocate_rrr<typename details::vec_binop_vecvec_node<Type,op1<Type> > > \
27791 (operation, branch[0], branch[1]); \
27795 default :
return error_node();
27798 else if (is_b0_ivec && !is_b1_ivec)
27802 #define case_stmt(op0,op1) \
27803 case op0 : return node_allocator_-> \
27804 template allocate_rrr<typename details::vec_binop_vecval_node<Type,op1<Type> > > \
27805 (operation, branch[0], branch[1]); \
27809 default :
return error_node();
27812 else if (!is_b0_ivec && is_b1_ivec)
27816 #define case_stmt(op0,op1) \
27817 case op0 : return node_allocator_-> \
27818 template allocate_rrr<typename details::vec_binop_valvec_node<Type,op1<Type> > > \
27819 (operation, branch[0], branch[1]); \
27823 default :
return error_node();
27827 return error_node();
27829 #undef batch_eqineq_logic_case
27838 #define vector_ops \
27839 case_stmt(details::e_add,details::add_op) \
27840 case_stmt(details::e_sub,details::sub_op) \
27841 case_stmt(details::e_mul,details::mul_op) \
27842 case_stmt(details::e_div,details::div_op) \
27843 case_stmt(details::e_mod,details::mod_op) \
27845 if (is_b0_ivec && is_b1_ivec)
27849 #define case_stmt(op0,op1) \
27850 case op0 : return node_allocator_-> \
27851 template allocate_rrr<typename details::vec_binop_vecvec_node<Type,op1<Type> > > \
27852 (operation, branch[0], branch[1]); \
27857 default :
return error_node();
27860 else if (is_b0_ivec && !is_b1_ivec)
27864 #define case_stmt(op0,op1) \
27865 case op0 : return node_allocator_-> \
27866 template allocate_rrr<typename details::vec_binop_vecval_node<Type,op1<Type> > > \
27867 (operation, branch[0], branch[1]); \
27872 default :
return error_node();
27875 else if (!is_b0_ivec && is_b1_ivec)
27879 #define case_stmt(op0,op1) \
27880 case op0 : return node_allocator_-> \
27881 template allocate_rrr<typename details::vec_binop_valvec_node<Type,op1<Type> > > \
27882 (operation, branch[0], branch[1]); \
27886 default :
return error_node();
27890 return error_node();
27903 #ifndef exprtk_disable_string_capabilities
27910 if (v0_is_ivar && v1_is_ivar)
27914 variable_node_ptr v0 = variable_node_ptr(0);
27915 variable_node_ptr v1 = variable_node_ptr(0);
27918 (0 != (v0 = dynamic_cast<variable_node_ptr>(branch[0]))) &&
27919 (0 != (v1 = dynamic_cast<variable_node_ptr>(branch[1])))
27927 else if (v0_is_ivec && v1_is_ivec)
27931 #ifndef exprtk_disable_string_capabilities
27932 else if (v0_is_str && v1_is_str)
27936 (branch[0], branch[1]);
27939 (branch[0], branch[1]);
27944 parser_->set_synthesis_error(
"Only variables, strings, vectors or vector elements can be swapped");
27946 return error_node();
27949 parser_->state_.activate_side_effect(
"synthesize_swap_expression()");
27954 #ifndef exprtk_disable_sc_andor
27963 std::equal_to<T>()(T(0),branch[0]->
value())
27968 std::not_equal_to<T>()(T(0),branch[0]->value())
27977 std::equal_to<T>()(T(0),branch[1]->value())
27982 std::not_equal_to<T>()(T(0),branch[1]->value())
27989 free_node(*node_allocator_, branch[0]);
27990 free_node(*node_allocator_, branch[1]);
27996 return synthesize_expression<scand_node_t,2>(operation, branch);
28000 return synthesize_expression<scor_node_t,2>(operation, branch);
28003 return error_node();
28008 return error_node();
28012 #define basic_opr_switch_statements \
28013 case_stmt(details::e_add, details::add_op) \
28014 case_stmt(details::e_sub, details::sub_op) \
28015 case_stmt(details::e_mul, details::mul_op) \
28016 case_stmt(details::e_div, details::div_op) \
28017 case_stmt(details::e_mod, details::mod_op) \
28018 case_stmt(details::e_pow, details::pow_op) \
28020 #define extended_opr_switch_statements \
28021 case_stmt(details:: e_lt, details:: lt_op) \
28022 case_stmt(details:: e_lte, details:: lte_op) \
28023 case_stmt(details:: e_gt, details:: gt_op) \
28024 case_stmt(details:: e_gte, details:: gte_op) \
28025 case_stmt(details:: e_eq, details:: eq_op) \
28026 case_stmt(details:: e_ne, details:: ne_op) \
28027 case_stmt(details:: e_and, details:: and_op) \
28028 case_stmt(details::e_nand, details::nand_op) \
28029 case_stmt(details:: e_or, details:: or_op) \
28030 case_stmt(details:: e_nor, details:: nor_op) \
28031 case_stmt(details:: e_xor, details:: xor_op) \
28032 case_stmt(details::e_xnor, details::xnor_op) \
28034 #ifndef exprtk_disable_cardinal_pow_optimisation
28035 template <
typename TType,
template <
typename,
typename>
class IPowNode>
28040 #define case_stmt(cp) \
28041 case cp : return node_allocator_-> \
28042 allocate<IPowNode<T,details::numeric::fast_exp<T,cp> > >(v); \
28060 default :
return error_node();
28066 const bool not_recipricol = (c >= T(0));
28071 else if (std::equal_to<T>()(T(2),c))
28073 return node_allocator_->
28074 template allocate_rr<typename details::vov_node<Type,details::mul_op<Type> > >(
v,
v);
28078 if (not_recipricol)
28079 return cardinal_pow_optimisation_impl<T,details::ipow_node>(
v,p);
28081 return cardinal_pow_optimisation_impl<T,details::ipowinv_node>(
v,p);
28093 const bool not_recipricol = (c >= T(0));
28096 node_allocator_->free(branch[1]);
28104 else if (not_recipricol)
28105 return cardinal_pow_optimisation_impl<expression_node_ptr,details::bipow_node>(branch[0],p);
28107 return cardinal_pow_optimisation_impl<expression_node_ptr,details::bipowninv_node>(branch[0],p);
28112 return error_node();
28120 inline expression_node_ptr cardinal_pow_optimisation(expression_node_ptr(&)[2])
28122 return error_node();
28135 if (left_neg && right_neg)
28151 return error_node();
28161 (branch[0],branch[1]));
28165 template allocate<typename details::binary_ext_node<Type,details::sub_op<Type> > >
28166 (branch[1],branch[0]);
28171 else if (left_neg && !right_neg)
28184 return error_node();
28191 template allocate<typename details::binary_ext_node<Type,details::sub_op<Type> > >
28192 (branch[1], branch[0]);
28198 (branch[0], branch[1]));
28204 (branch[0], branch[1]));
28210 (branch[0], branch[1]));
28212 default :
return error_node();
28216 else if (!left_neg && right_neg)
28229 return error_node();
28236 template allocate<typename details::binary_ext_node<Type,details::sub_op<Type> > >
28237 (branch[0], branch[1]);
28241 template allocate<typename details::binary_ext_node<Type,details::add_op<Type> > >
28242 (branch[0], branch[1]);
28248 (branch[0], branch[1]));
28254 (branch[0], branch[1]));
28256 default :
return error_node();
28263 #define case_stmt(op0,op1) \
28264 case op0 : return expr_gen.node_allocator_-> \
28265 template allocate<typename details::binary_ext_node<Type,op1<Type> > > \
28266 (branch[0], branch[1]); \
28271 default :
return error_node();
28284 #ifndef exprtk_disable_enhanced_features
28289 const bool synthesis_result = synthesize_sf4ext_expression::template compile_right<vtype>
28290 (expr_gen,
v, operation, branch[1], result);
28292 if (synthesis_result)
28294 free_node(*expr_gen.node_allocator_,branch[1]);
28313 const Type& v1 =
static_cast<uvbn_ptr_t
>(branch[1])->
v();
28321 template allocate_rr<
typename details::
28326 template allocate_rr<
typename details::
28337 #define case_stmt(op0,op1) \
28338 case op0 : return expr_gen.node_allocator_-> \
28339 template allocate_rc<typename details::vob_node<Type,op1<Type> > > \
28345 default :
return error_node();
28358 #ifndef exprtk_disable_enhanced_features
28363 const bool synthesis_result = synthesize_sf4ext_expression::template compile_left<vtype>
28364 (expr_gen,
v, operation, branch[0], result);
28366 if (synthesis_result)
28368 free_node(*expr_gen.node_allocator_, branch[0]);
28390 const Type& v0 =
static_cast<uvbn_ptr_t
>(branch[0])->
v();
28397 template allocate_rr<
typename details::
28402 template allocate_rr<
typename details::
28407 template allocate_rr<
typename details::
28412 template allocate_rr<
typename details::
28422 #define case_stmt(op0,op1) \
28423 case op0 : return expr_gen.node_allocator_-> \
28424 template allocate_cr<typename details::bov_node<Type,op1<Type> > > \
28430 default :
return error_node();
28445 if (std::equal_to<T>()(T(0),c) && (
details::e_mul == operation))
28449 return expr_gen(T(0));
28451 else if (std::equal_to<T>()(T(0),c) && (
details::e_div == operation))
28455 return expr_gen(T(0));
28457 else if (std::equal_to<T>()(T(0),c) && (
details::e_add == operation))
28459 else if (std::equal_to<T>()(T(1),c) && (
details::e_mul == operation))
28480 default :
return error_node();
28501 default :
return error_node();
28522 template allocate_tt<typename details::cob_node<Type,details::mul_op<Type> > >
28527 template allocate_tt<typename details::cob_node<Type,details::div_op<Type> > >
28531 default :
return error_node();
28536 return new_cobnode;
28540 #ifndef exprtk_disable_enhanced_features
28545 if (synthesize_sf4ext_expression::template compile_right<ctype>(expr_gen,c,operation,branch[1],result))
28556 #define case_stmt(op0,op1) \
28557 case op0 : return expr_gen.node_allocator_-> \
28558 template allocate_tt<typename details::cob_node<Type,op1<Type> > > \
28564 default :
return error_node();
28579 if (std::equal_to<T>()(T(0),c) && (
details::e_mul == operation))
28583 return expr_gen(T(0));
28585 else if (std::equal_to<T>()(T(0),c) && (
details::e_div == operation))
28589 return expr_gen(std::numeric_limits<T>::quiet_NaN());
28591 else if (std::equal_to<T>()(T(0),c) && (
details::e_add == operation))
28593 else if (std::equal_to<T>()(T(1),c) && (
details::e_mul == operation))
28614 default :
return error_node();
28634 default :
return error_node();
28648 bocnode->
set_c(bocnode->
c() * c);
28655 #ifndef exprtk_disable_enhanced_features
28660 const bool synthesis_result = synthesize_sf4ext_expression::template compile_left<ctype>
28661 (expr_gen, c, operation, branch[0], result);
28663 if (synthesis_result)
28665 free_node(*expr_gen.node_allocator_, branch[0]);
28674 #define case_stmt(op0,op1) \
28675 case op0 : return expr_gen.node_allocator_-> \
28676 template allocate_cr<typename details::boc_node<Type,op1<Type> > > \
28682 default :
return error_node();
28702 if (std::equal_to<T>()(T(0),c) && (
details::e_mul == operation))
28707 return expr_gen(T(0));
28709 else if (std::equal_to<T>()(T(0),c) && (
details::e_div == operation))
28714 return expr_gen(T(std::numeric_limits<T>::quiet_NaN()));
28716 else if (std::equal_to<T>()(T(0),c) && (
details::e_add == operation))
28722 else if (std::equal_to<T>()(T(1),c) && (
details::e_mul == operation))
28728 else if (std::equal_to<T>()(T(1),c) && (
details::e_div == operation))
28744 default :
return error_node();
28755 default :
return error_node();
28764 cobnode->
set_c(cobnode->
c() * c);
28770 template allocate_tt<typename details::cob_node<Type,details::div_op<Type> > >
28790 if (std::equal_to<T>()(T(0),c) && (
details::e_mul == operation))
28795 return expr_gen(T(0));
28797 else if (std::equal_to<T>()(T(0),c) && (
details::e_div == operation))
28802 return expr_gen(T(0));
28804 else if (std::equal_to<T>()(T(0),c) && (
details::e_add == operation))
28810 else if (std::equal_to<T>()(T(1),c) && (
details::e_mul == operation))
28821 cobnode->
set_c(c + cobnode->
c());
28827 template allocate_tt<typename details::cob_node<Type,details::sub_op<Type> > >
28837 cobnode->
set_c(c + cobnode->
c());
28843 template allocate_tt<typename details::cob_node<Type,details::add_op<Type> > >
28853 cobnode->
set_c(c * cobnode->
c());
28859 template allocate_tt<typename details::cob_node<Type,details::div_op<Type> > >
28869 cobnode->
set_c(c * cobnode->
c());
28875 template allocate_tt<typename details::cob_node<Type,details::mul_op<Type> > >
28913 default :
return error_node();
28924 default :
return error_node();
28934 template allocate_tt<typename details::boc_node<Type,details::add_op<Type> > >
28941 bocnode->
set_c(bocnode->
c() + c);
28951 default :
return error_node();
28974 bocnode->
set_c(c + bocnode->
c());
28980 template allocate_tt<typename details::cob_node<Type,details::sub_op<Type> > >
28991 template allocate_tt<typename details::boc_node<Type,details::add_op<Type> > >
28999 template allocate_tt<typename details::cob_node<Type,details::sub_op<Type> > >
29009 bocnode->
set_c(c * bocnode->
c());
29015 template allocate_tt<typename details::cob_node<Type,details::div_op<Type> > >
29025 bocnode->
set_c(bocnode->
c() / c);
29031 template allocate_tt<typename details::cob_node<Type,details::div_op<Type> > >
29048 #ifndef exprtk_disable_enhanced_features
29053 result = error_node();
29055 if (!operation_optimisable(operation))
29058 const std::string node_id = branch_to_id(branch);
29060 const typename synthesize_map_t::iterator itr = synthesize_map_.find(node_id);
29062 if (synthesize_map_.end() != itr)
29064 result = itr->second((*
this), operation, branch);
29083 #define case_stmt(op0,op1) \
29084 case op0 : return expr_gen.node_allocator_-> \
29085 template allocate_rr<typename details::vov_node<Type,op1<Type> > > \
29091 default :
return error_node();
29107 if (std::equal_to<T>()(T(0),c) && (
details::e_mul == operation))
29108 return expr_gen(T(0));
29109 else if (std::equal_to<T>()(T(0),c) && (
details::e_div == operation))
29110 return expr_gen(T(0));
29111 else if (std::equal_to<T>()(T(0),c) && (
details::e_add == operation))
29113 else if (std::equal_to<T>()(T(1),c) && (
details::e_mul == operation))
29118 #define case_stmt(op0,op1) \
29119 case op0 : return expr_gen.node_allocator_-> \
29120 template allocate_cr<typename details::cov_node<Type,op1<Type> > > \
29126 default :
return error_node();
29144 if (std::equal_to<T>()(T(1),c))
29149 else if (std::equal_to<T>()(T(0),c) && (
details::e_mul == operation))
29150 return expr_gen(T(0));
29151 else if (std::equal_to<T>()(T(0),c) && (
details::e_div == operation))
29152 return expr_gen(std::numeric_limits<T>::quiet_NaN());
29153 else if (std::equal_to<T>()(T(0),c) && (
details::e_add == operation))
29155 else if (std::equal_to<T>()(T(1),c) && (
details::e_mul == operation))
29157 else if (std::equal_to<T>()(T(1),c) && (
details::e_div == operation))
29162 #define case_stmt(op0,op1) \
29163 case op0 : return expr_gen.node_allocator_-> \
29164 template allocate_rc<typename details::voc_node<Type,op1<Type> > > \
29170 default :
return error_node();
29177 template <
typename T0,
typename T1,
typename T2>
29180 T0 t0, T1 t1, T2 t2)
29184 #define case_stmt(op) \
29185 case details::e_sf##op : return details::T0oT1oT2_sf3ext<T,T0,T1,T2,details::sf##op##_op<Type> >:: \
29186 allocate(*(expr_gen.node_allocator_), t0, t1, t2); \
29197 default :
return error_node();
29201 template <
typename T0,
typename T1,
typename T2>
29203 T0 t0, T1 t1, T2 t2,
29211 result = synthesize_sf3ext_expression::template process<T0,T1,T2>(expr_gen,sf3opr,t0,t1,t2);
29219 template <
typename T0,
typename T1,
typename T2,
typename T3>
29222 T0 t0, T1 t1, T2 t2, T3 t3)
29226 #define case_stmt0(op) \
29227 case details::e_sf##op : return details::T0oT1oT2oT3_sf4ext<Type,T0,T1,T2,T3,details::sf##op##_op<Type> >:: \
29228 allocate(*(expr_gen.node_allocator_), t0, t1, t2, t3); \
29231 #define case_stmt1(op) \
29232 case details::e_sf4ext##op : return details::T0oT1oT2oT3_sf4ext<Type,T0,T1,T2,T3,details::sfext##op##_op<Type> >:: \
29233 allocate(*(expr_gen.node_allocator_), t0, t1, t2, t3); \
29264 default :
return error_node();
29268 template <
typename T0,
typename T1,
typename T2,
typename T3>
29270 T0 t0, T1 t1, T2 t2, T3 t3,
29278 result = synthesize_sf4ext_expression::template process<T0,T1,T2,T3>
29279 (expr_gen, sf4opr, t0, t1, t2, t3);
29285 template <
typename ExternalType>
29297 sf3ext_base_ptr n =
static_cast<sf3ext_base_ptr
>(sf3node);
29298 std::string
id =
"t" + expr_gen.
to_str(operation) +
"(" + n->type_id() +
")";
29304 (expr_gen, id,
t, sf3node, result);
29308 (expr_gen, id,
t, sf3node, result);
29312 (expr_gen, id,
t, sf3node, result);
29316 (expr_gen, id,
t, sf3node, result);
29320 (expr_gen, id,
t, sf3node, result);
29322 default :
return false;
29327 template <
typename ExternalType>
29339 sf3ext_base_ptr n =
static_cast<sf3ext_base_ptr
>(sf3node);
29341 std::string
id =
"(" + n->
type_id() +
")" + expr_gen.
to_str(operation) +
"t";
29347 (expr_gen, id,
t, sf3node, result);
29351 (expr_gen, id,
t, sf3node, result);
29355 (expr_gen, id,
t, sf3node, result);
29359 (expr_gen, id,
t, sf3node, result);
29363 (expr_gen, id,
t, sf3node, result);
29365 default :
return false;
29369 template <
typename SF3TypeNode,
typename ExternalType,
typename T0,
typename T1,
typename T2>
29371 const std::string&
id,
29376 SF3TypeNode* n =
dynamic_cast<SF3TypeNode*
>(node);
29384 return synthesize_sf4ext_expression::template compile<ExternalType,T0,T1,T2>
29385 (expr_gen, id,
t, t0, t1, t2, result);
29391 template <
typename SF3TypeNode,
typename ExternalType,
typename T0,
typename T1,
typename T2>
29393 const std::string&
id,
29398 SF3TypeNode* n =
dynamic_cast<SF3TypeNode*
>(node);
29406 return synthesize_sf4ext_expression::template compile<T0,T1,T2,ExternalType>
29407 (expr_gen, id, t0, t1, t2,
t, result);
29425 const Type& v0 = vov->
v0();
29426 const Type& v1 = vov->
v1();
29443 const bool synthesis_result =
29444 synthesize_sf3ext_expression::
29445 template compile<vtype,vtype,vtype>(expr_gen,
"t/(t*t)", v0, v1, v2, result);
29447 exprtk_debug((
"(v0 / v1) / v2 --> (vovov) v0 / (v1 * v2)\n"));
29449 return (synthesis_result) ? result : error_node();
29453 const bool synthesis_result =
29454 synthesize_sf3ext_expression::template compile<vtype, vtype, vtype>
29455 (expr_gen, id(expr_gen, o0, o1), v0, v1, v2, result);
29457 if (synthesis_result)
29459 else if (!expr_gen.valid_operator(o0,f0))
29460 return error_node();
29461 else if (!expr_gen.valid_operator(o1,f1))
29462 return error_node();
29464 return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, f0, f1);
29486 const Type& v1 = vov->
v0();
29487 const Type& v2 = vov->
v1();
29503 const bool synthesis_result =
29504 synthesize_sf3ext_expression::
29505 template compile<vtype,vtype,vtype>(expr_gen,
"(t*t)/t", v0, v2, v1, result);
29507 exprtk_debug((
"v0 / (v1 / v2) --> (vovov) (v0 * v2) / v1\n"));
29509 return (synthesis_result) ? result : error_node();
29513 const bool synthesis_result =
29514 synthesize_sf3ext_expression::template compile<vtype, vtype, vtype>
29515 (expr_gen, id(expr_gen, o0, o1), v0, v1, v2, result);
29517 if (synthesis_result)
29519 else if (!expr_gen.valid_operator(o0,f0))
29520 return error_node();
29521 else if (!expr_gen.valid_operator(o1,f1))
29522 return error_node();
29524 return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, f0, f1);
29545 const Type& v0 = vov->
v0();
29546 const Type& v1 = vov->
v1();
29564 const bool synthesis_result =
29565 synthesize_sf3ext_expression::
29566 template compile<vtype,vtype,ctype>(expr_gen,
"t/(t*t)", v0, v1, c, result);
29568 exprtk_debug((
"(v0 / v1) / c --> (vovoc) v0 / (v1 * c)\n"));
29570 return (synthesis_result) ? result : error_node();
29574 const bool synthesis_result =
29575 synthesize_sf3ext_expression::template compile<vtype, vtype, ctype>
29576 (expr_gen, id(expr_gen, o0, o1), v0, v1, c, result);
29578 if (synthesis_result)
29580 else if (!expr_gen.valid_operator(o0,f0))
29581 return error_node();
29582 else if (!expr_gen.valid_operator(o1,f1))
29583 return error_node();
29585 return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, c, f0, f1);
29607 const Type& v1 = voc->
v();
29608 const Type c = voc->
c();
29624 const bool synthesis_result =
29625 synthesize_sf3ext_expression::
29626 template compile<vtype,ctype,vtype>(expr_gen,
"(t*t)/t", v0, c, v1, result);
29628 exprtk_debug((
"v0 / (v1 / c) --> (vocov) (v0 * c) / v1\n"));
29630 return (synthesis_result) ? result : error_node();
29634 const bool synthesis_result =
29635 synthesize_sf3ext_expression::template compile<vtype, vtype, ctype>
29636 (expr_gen, id(expr_gen, o0, o1), v0, v1, c, result);
29638 if (synthesis_result)
29640 else if (!expr_gen.valid_operator(o0,f0))
29641 return error_node();
29642 else if (!expr_gen.valid_operator(o1,f1))
29643 return error_node();
29645 return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, c, f0, f1);
29666 const Type& v0 = voc->
v();
29667 const Type c = voc->
c();
29684 const bool synthesis_result =
29685 synthesize_sf3ext_expression::
29686 template compile<vtype,vtype,ctype>(expr_gen,
"t/(t*t)", v0, v1, c, result);
29688 exprtk_debug((
"(v0 / c) / v1 --> (vovoc) v0 / (v1 * c)\n"));
29690 return (synthesis_result) ? result : error_node();
29694 const bool synthesis_result =
29695 synthesize_sf3ext_expression::template compile<vtype, ctype, vtype>
29696 (expr_gen, id(expr_gen, o0, o1), v0, c, v1, result);
29698 if (synthesis_result)
29700 else if (!expr_gen.valid_operator(o0,f0))
29701 return error_node();
29702 else if (!expr_gen.valid_operator(o1,f1))
29703 return error_node();
29705 return node_type::allocate(*(expr_gen.node_allocator_), v0, c, v1, f0, f1);
29727 const Type c = cov->
c();
29728 const Type& v1 = cov->
v();
29744 const bool synthesis_result =
29745 synthesize_sf3ext_expression::
29746 template compile<vtype, vtype, ctype>(expr_gen,
"(t*t)/t", v0, v1, c, result);
29748 exprtk_debug((
"v0 / (c / v1) --> (vovoc) (v0 * v1) / c\n"));
29750 return (synthesis_result) ? result : error_node();
29754 const bool synthesis_result =
29755 synthesize_sf3ext_expression::template compile<vtype, ctype, vtype>
29756 (expr_gen, id(expr_gen, o0, o1), v0, c, v1, result);
29758 if (synthesis_result)
29760 else if (!expr_gen.valid_operator(o0,f0))
29761 return error_node();
29762 else if (!expr_gen.valid_operator(o1,f1))
29763 return error_node();
29765 return node_type::allocate(*(expr_gen.node_allocator_), v0, c, v1, f0, f1);
29786 const Type c = cov->
c();
29787 const Type& v0 = cov->
v();
29804 const bool synthesis_result =
29805 synthesize_sf3ext_expression::
29806 template compile<ctype, vtype, vtype>(expr_gen,
"t/(t*t)", c, v0, v1, result);
29808 exprtk_debug((
"(c / v0) / v1 --> (covov) c / (v0 * v1)\n"));
29810 return (synthesis_result) ? result : error_node();
29814 const bool synthesis_result =
29815 synthesize_sf3ext_expression::template compile<ctype, vtype, vtype>
29816 (expr_gen, id(expr_gen, o0, o1), c, v0, v1, result);
29818 if (synthesis_result)
29820 else if (!expr_gen.valid_operator(o0,f0))
29821 return error_node();
29822 else if (!expr_gen.valid_operator(o1,f1))
29823 return error_node();
29825 return node_type::allocate(*(expr_gen.node_allocator_), c, v0, v1, f0, f1);
29847 const Type& v0 = vov->
v0();
29848 const Type& v1 = vov->
v1();
29865 const bool synthesis_result =
29866 synthesize_sf3ext_expression::
29867 template compile<ctype, vtype, vtype>(expr_gen,
"(t*t)/t", c, v1, v0, result);
29869 exprtk_debug((
"c / (v0 / v1) --> (covov) (c * v1) / v0\n"));
29871 return (synthesis_result) ? result : error_node();
29875 const bool synthesis_result =
29876 synthesize_sf3ext_expression::template compile<ctype, vtype, vtype>
29877 (expr_gen, id(expr_gen, o0, o1), c, v0, v1, result);
29879 if (synthesis_result)
29881 else if (!expr_gen.valid_operator(o0,f0))
29882 return error_node();
29883 else if (!expr_gen.valid_operator(o1,f1))
29884 return error_node();
29886 return node_type::allocate(*(expr_gen.node_allocator_), c, v0, v1, f0, f1);
29906 const Type c0 = cov->
c();
29907 const Type&
v = cov->
v();
29925 exprtk_debug((
"(c0 + v) + c1 --> (cov) (c0 + c1) + v\n"));
29928 template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 + c1,
v);
29933 exprtk_debug((
"(c0 + v) - c1 --> (cov) (c0 - c1) + v\n"));
29936 template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 - c1,
v);
29941 exprtk_debug((
"(c0 - v) + c1 --> (cov) (c0 + c1) - v\n"));
29944 template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 + c1,
v);
29949 exprtk_debug((
"(c0 - v) - c1 --> (cov) (c0 - c1) - v\n"));
29952 template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 - c1,
v);
29957 exprtk_debug((
"(c0 * v) * c1 --> (cov) (c0 * c1) * v\n"));
29960 template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 * c1,
v);
29965 exprtk_debug((
"(c0 * v) / c1 --> (cov) (c0 / c1) * v\n"));
29968 template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 / c1,
v);
29973 exprtk_debug((
"(c0 / v) * c1 --> (cov) (c0 * c1) / v\n"));
29976 template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 * c1,
v);
29981 exprtk_debug((
"(c0 / v) / c1 --> (cov) (c0 / c1) / v\n"));
29984 template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 / c1,
v);
29988 const bool synthesis_result =
29989 synthesize_sf3ext_expression::template compile<ctype, vtype, ctype>
29990 (expr_gen, id(expr_gen, o0, o1), c0,
v, c1,result);
29992 if (synthesis_result)
29994 else if (!expr_gen.valid_operator(o0,f0))
29995 return error_node();
29996 else if (!expr_gen.valid_operator(o1,f1))
29997 return error_node();
29999 return node_type::allocate(*(expr_gen.node_allocator_), c0, v, c1, f0, f1);
30021 const Type&
v = voc->
v();
30022 const Type c1 = voc->
c();
30039 exprtk_debug((
"(c0) + (v + c1) --> (cov) (c0 + c1) + v\n"));
30042 template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 + c1,
v);
30047 exprtk_debug((
"(c0) + (v - c1) --> (cov) (c0 - c1) + v\n"));
30050 template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 - c1,
v);
30055 exprtk_debug((
"(c0) - (v + c1) --> (cov) (c0 - c1) - v\n"));
30058 template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 - c1,
v);
30063 exprtk_debug((
"(c0) - (v - c1) --> (cov) (c0 + c1) - v\n"));
30066 template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 + c1,
v);
30071 exprtk_debug((
"(c0) * (v * c1) --> (voc) v * (c0 * c1)\n"));
30074 template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 * c1,
v);
30079 exprtk_debug((
"(c0) * (v / c1) --> (cov) (c0 / c1) * v\n"));
30082 template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 / c1,
v);
30087 exprtk_debug((
"(c0) / (v * c1) --> (cov) (c0 / c1) / v\n"));
30090 template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 / c1,
v);
30095 exprtk_debug((
"(c0) / (v / c1) --> (cov) (c0 * c1) / v\n"));
30098 template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 * c1,
v);
30102 const bool synthesis_result =
30103 synthesize_sf3ext_expression::template compile<ctype, vtype, ctype>
30104 (expr_gen, id(expr_gen, o0, o1), c0,
v, c1, result);
30106 if (synthesis_result)
30108 else if (!expr_gen.valid_operator(o0,f0))
30109 return error_node();
30110 else if (!expr_gen.valid_operator(o1,f1))
30111 return error_node();
30113 return node_type::allocate(*(expr_gen.node_allocator_), c0, v, c1, f0, f1);
30129 return error_node();
30145 const Type c1 = cov->
c();
30146 const Type&
v = cov->
v();
30163 exprtk_debug((
"(c0) + (c1 + v) --> (cov) (c0 + c1) + v\n"));
30166 template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 + c1,
v);
30171 exprtk_debug((
"(c0) + (c1 - v) --> (cov) (c0 + c1) - v\n"));
30174 template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 + c1,
v);
30179 exprtk_debug((
"(c0) - (c1 + v) --> (cov) (c0 - c1) - v\n"));
30182 template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 - c1,
v);
30187 exprtk_debug((
"(c0) - (c1 - v) --> (cov) (c0 - c1) + v\n"));
30190 template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 - c1,
v);
30195 exprtk_debug((
"(c0) * (c1 * v) --> (cov) (c0 * c1) * v\n"));
30198 template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 * c1,
v);
30203 exprtk_debug((
"(c0) * (c1 / v) --> (cov) (c0 * c1) / v\n"));
30206 template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 * c1,
v);
30211 exprtk_debug((
"(c0) / (c1 * v) --> (cov) (c0 / c1) / v\n"));
30214 template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 / c1,
v);
30219 exprtk_debug((
"(c0) / (c1 / v) --> (cov) (c0 / c1) * v\n"));
30222 template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 / c1,
v);
30226 const bool synthesis_result =
30227 synthesize_sf3ext_expression::template compile<ctype, ctype, vtype>
30228 (expr_gen, id(expr_gen, o0, o1), c0, c1,
v, result);
30230 if (synthesis_result)
30232 else if (!expr_gen.valid_operator(o0,f0))
30233 return error_node();
30234 else if (!expr_gen.valid_operator(o1,f1))
30235 return error_node();
30237 return node_type::allocate(*(expr_gen.node_allocator_), c0, c1, v, f0, f1);
30257 const Type&
v = voc->
v();
30258 const Type& c0 = voc->
c();
30276 exprtk_debug((
"(v + c0) + c1 --> (voc) v + (c0 + c1)\n"));
30279 template allocate_rc<typename details::voc_node<Type,details::add_op<Type> > >(
v, c0 + c1);
30284 exprtk_debug((
"(v + c0) - c1 --> (voc) v + (c0 - c1)\n"));
30287 template allocate_rc<typename details::voc_node<Type,details::add_op<Type> > >(
v, c0 - c1);
30292 exprtk_debug((
"(v - c0) + c1 --> (voc) v - (c0 + c1)\n"));
30295 template allocate_rc<typename details::voc_node<Type,details::add_op<Type> > >(
v, c1 - c0);
30300 exprtk_debug((
"(v - c0) - c1 --> (voc) v - (c0 + c1)\n"));
30303 template allocate_rc<typename details::voc_node<Type,details::sub_op<Type> > >(
v, c0 + c1);
30308 exprtk_debug((
"(v * c0) * c1 --> (voc) v * (c0 * c1)\n"));
30311 template allocate_rc<typename details::voc_node<Type,details::mul_op<Type> > >(
v, c0 * c1);
30316 exprtk_debug((
"(v * c0) / c1 --> (voc) v * (c0 / c1)\n"));
30319 template allocate_rc<typename details::voc_node<Type,details::mul_op<Type> > >(
v, c0 / c1);
30324 exprtk_debug((
"(v / c0) * c1 --> (voc) v * (c1 / c0)\n"));
30327 template allocate_rc<typename details::voc_node<Type,details::mul_op<Type> > >(
v, c1 / c0);
30332 exprtk_debug((
"(v / c0) / c1 --> (voc) v / (c0 * c1)\n"));
30335 template allocate_rc<typename details::voc_node<Type,details::div_op<Type> > >(
v, c0 * c1);
30340 exprtk_debug((
"(v ^ c0) ^ c1 --> (voc) v ^ (c0 * c1)\n"));
30343 template allocate_rc<typename details::voc_node<Type,details::pow_op<Type> > >(
v, c0 * c1);
30347 const bool synthesis_result =
30348 synthesize_sf3ext_expression::template compile<vtype, ctype, ctype>
30349 (expr_gen, id(expr_gen, o0, o1),
v, c0, c1, result);
30351 if (synthesis_result)
30353 else if (!expr_gen.valid_operator(o0,f0))
30354 return error_node();
30355 else if (!expr_gen.valid_operator(o1,f1))
30356 return error_node();
30358 return node_type::allocate(*(expr_gen.node_allocator_), v, c0, c1, f0, f1);
30375 exprtk_debug((
"(v) o0 (c0 o1 c1) - Not possible.\n"));
30376 return error_node();
30396 const Type& v0 = vov0->
v0();
30397 const Type& v1 = vov0->
v1();
30398 const Type& v2 = vov1->
v0();
30399 const Type& v3 = vov1->
v1();
30418 const bool synthesis_result =
30419 synthesize_sf4ext_expression::
30420 template compile<vtype,vtype,vtype,vtype>(expr_gen,
"(t*t)/(t*t)", v0, v2, v1, v3, result);
30422 exprtk_debug((
"(v0 / v1) * (v2 / v3) --> (vovovov) (v0 * v2) / (v1 * v3)\n"));
30424 return (synthesis_result) ? result : error_node();
30429 const bool synthesis_result =
30430 synthesize_sf4ext_expression::
30431 template compile<vtype,vtype,vtype,vtype>(expr_gen,
"(t*t)/(t*t)", v0, v3, v1, v2, result);
30433 exprtk_debug((
"(v0 / v1) / (v2 / v3) --> (vovovov) (v0 * v3) / (v1 * v2)\n"));
30435 return (synthesis_result) ? result : error_node();
30440 const bool synthesis_result =
30441 synthesize_sf4ext_expression::
30442 template compile<vtype,vtype,vtype,vtype>(expr_gen,
"(t+t)*(t/t)", v0, v1, v3, v2, result);
30444 exprtk_debug((
"(v0 + v1) / (v2 / v3) --> (vovovov) (v0 + v1) * (v3 / v2)\n"));
30446 return (synthesis_result) ? result : error_node();
30451 const bool synthesis_result =
30452 synthesize_sf4ext_expression::
30453 template compile<vtype,vtype,vtype,vtype>(expr_gen,
"(t-t)*(t/t)", v0, v1, v3, v2, result);
30455 exprtk_debug((
"(v0 - v1) / (v2 / v3) --> (vovovov) (v0 - v1) * (v3 / v2)\n"));
30457 return (synthesis_result) ? result : error_node();
30462 const bool synthesis_result =
30463 synthesize_sf4ext_expression::
30464 template compile<vtype,vtype,vtype,vtype>(expr_gen,
"((t*t)*t)/t", v0, v1, v3, v2, result);
30466 exprtk_debug((
"(v0 * v1) / (v2 / v3) --> (vovovov) ((v0 * v1) * v3) / v2\n"));
30468 return (synthesis_result) ? result : error_node();
30472 const bool synthesis_result =
30473 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
30474 (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, v2, v3,result);
30476 if (synthesis_result)
30478 else if (!expr_gen.valid_operator(o0,f0))
30479 return error_node();
30480 else if (!expr_gen.valid_operator(o1,f1))
30481 return error_node();
30482 else if (!expr_gen.valid_operator(o2,f2))
30483 return error_node();
30485 return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, v3, f0, f1, f2);
30513 const Type& v0 = vov->
v0();
30514 const Type& v1 = vov->
v1();
30515 const Type& v2 = voc->v ();
30516 const Type c = voc->c ();
30535 const bool synthesis_result =
30536 synthesize_sf4ext_expression::
30537 template compile<vtype,vtype,vtype,ctype>(expr_gen,
"(t*t)/(t*t)", v0, v2, v1, c, result);
30539 exprtk_debug((
"(v0 / v1) * (v2 / c) --> (vovovoc) (v0 * v2) / (v1 * c)\n"));
30541 return (synthesis_result) ? result : error_node();
30546 const bool synthesis_result =
30547 synthesize_sf4ext_expression::
30548 template compile<vtype,ctype,vtype,vtype>(expr_gen,
"(t*t)/(t*t)", v0, c, v1, v2, result);
30550 exprtk_debug((
"(v0 / v1) / (v2 / c) --> (vocovov) (v0 * c) / (v1 * v2)\n"));
30552 return (synthesis_result) ? result : error_node();
30556 const bool synthesis_result =
30557 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
30558 (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, v2, c, result);
30560 if (synthesis_result)
30562 else if (!expr_gen.valid_operator(o0,f0))
30563 return error_node();
30564 else if (!expr_gen.valid_operator(o1,f1))
30565 return error_node();
30566 else if (!expr_gen.valid_operator(o2,f2))
30567 return error_node();
30569 return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, c, f0, f1, f2);
30597 const Type& v0 = vov->
v0();
30598 const Type& v1 = vov->
v1();
30599 const Type& v2 = cov->v ();
30600 const Type c = cov->c ();
30619 const bool synthesis_result =
30620 synthesize_sf4ext_expression::
30621 template compile<vtype,ctype,vtype,vtype>(expr_gen,
"(t*t)/(t*t)", v0, c, v1, v2, result);
30623 exprtk_debug((
"(v0 / v1) * (c / v2) --> (vocovov) (v0 * c) / (v1 * v2)\n"));
30625 return (synthesis_result) ? result : error_node();
30630 const bool synthesis_result =
30631 synthesize_sf4ext_expression::
30632 template compile<vtype,vtype,vtype,ctype>(expr_gen,
"(t*t)/(t*t)", v0, v2, v1, c, result);
30634 exprtk_debug((
"(v0 / v1) / (c / v2) --> (vovovoc) (v0 * v2) / (v1 * c)\n"));
30636 return (synthesis_result) ? result : error_node();
30640 const bool synthesis_result =
30641 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
30642 (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, c, v2, result);
30644 if (synthesis_result)
30646 else if (!expr_gen.valid_operator(o0,f0))
30647 return error_node();
30648 else if (!expr_gen.valid_operator(o1,f1))
30649 return error_node();
30650 else if (!expr_gen.valid_operator(o2,f2))
30651 return error_node();
30653 return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, c, v2, f0, f1, f2);
30681 const Type c = voc->
c ();
30682 const Type& v0 = voc->
v ();
30683 const Type& v1 = vov->v0();
30684 const Type& v2 = vov->v1();
30703 const bool synthesis_result =
30704 synthesize_sf4ext_expression::
30705 template compile<vtype,vtype,ctype,vtype>(expr_gen,
"(t*t)/(t*t)", v0, v1, c, v2, result);
30707 exprtk_debug((
"(v0 / c) * (v1 / v2) --> (vovocov) (v0 * v1) / (c * v2)\n"));
30709 return (synthesis_result) ? result : error_node();
30714 const bool synthesis_result =
30715 synthesize_sf4ext_expression::
30716 template compile<vtype,vtype,ctype,vtype>(expr_gen,
"(t*t)/(t*t)", v0, v2, c, v1, result);
30718 exprtk_debug((
"(v0 / c) / (v1 / v2) --> (vovocov) (v0 * v2) / (c * v1)\n"));
30720 return (synthesis_result) ? result : error_node();
30724 const bool synthesis_result =
30725 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
30726 (expr_gen, id(expr_gen, o0, o1, o2), v0, c, v1, v2, result);
30728 if (synthesis_result)
30730 else if (!expr_gen.valid_operator(o0,f0))
30731 return error_node();
30732 else if (!expr_gen.valid_operator(o1,f1))
30733 return error_node();
30734 else if (!expr_gen.valid_operator(o2,f2))
30735 return error_node();
30737 return node_type::allocate(*(expr_gen.node_allocator_), v0, c, v1, v2, f0, f1, f2);
30765 const Type c = cov->
c ();
30766 const Type& v0 = cov->
v ();
30767 const Type& v1 = vov->v0();
30768 const Type& v2 = vov->v1();
30787 const bool synthesis_result =
30788 synthesize_sf4ext_expression::
30789 template compile<ctype,vtype,vtype,vtype>(expr_gen,
"(t*t)/(t*t)", c, v1, v0, v2, result);
30791 exprtk_debug((
"(c / v0) * (v1 / v2) --> (covovov) (c * v1) / (v0 * v2)\n"));
30793 return (synthesis_result) ? result : error_node();
30798 const bool synthesis_result =
30799 synthesize_sf4ext_expression::
30800 template compile<ctype,vtype,vtype,vtype>(expr_gen,
"(t*t)/(t*t)", c, v2, v0, v1, result);
30802 exprtk_debug((
"(c / v0) / (v1 / v2) --> (covovov) (c * v2) / (v0 * v1)\n"));
30804 return (synthesis_result) ? result : error_node();
30808 const bool synthesis_result =
30809 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
30810 (expr_gen, id(expr_gen, o0, o1, o2), c, v0, v1, v2, result);
30812 if (synthesis_result)
30814 else if (!expr_gen.valid_operator(o0,f0))
30815 return error_node();
30816 else if (!expr_gen.valid_operator(o1,f1))
30817 return error_node();
30818 else if (!expr_gen.valid_operator(o2,f2))
30819 return error_node();
30821 return node_type::allocate(*(expr_gen.node_allocator_), c, v0, v1, v2, f0, f1, f2);
30849 const Type c0 = cov0->
c();
30850 const Type& v0 = cov0->
v();
30851 const Type c1 = cov1->
c();
30852 const Type& v1 = cov1->
v();
30871 const bool synthesis_result =
30872 synthesize_sf3ext_expression::
30873 template compile<ctype,vtype,vtype>(expr_gen,
"(t+t)+t", (c0 + c1), v0, v1, result);
30875 exprtk_debug((
"(c0 + v0) + (c1 + v1) --> (covov) (c0 + c1) + v0 + v1\n"));
30877 return (synthesis_result) ? result : error_node();
30882 const bool synthesis_result =
30883 synthesize_sf3ext_expression::
30884 template compile<ctype,vtype,vtype>(expr_gen,
"(t+t)-t", (c0 - c1), v0, v1, result);
30886 exprtk_debug((
"(c0 + v0) - (c1 + v1) --> (covov) (c0 - c1) + v0 - v1\n"));
30888 return (synthesis_result) ? result : error_node();
30893 const bool synthesis_result =
30894 synthesize_sf3ext_expression::
30895 template compile<ctype,vtype,vtype>(expr_gen,
"(t-t)+t", (c0 - c1), v0, v1, result);
30897 exprtk_debug((
"(c0 - v0) - (c1 - v1) --> (covov) (c0 - c1) - v0 + v1\n"));
30899 return (synthesis_result) ? result : error_node();
30904 const bool synthesis_result =
30905 synthesize_sf3ext_expression::
30906 template compile<ctype,vtype,vtype>(expr_gen,
"(t*t)*t", (c0 * c1), v0, v1, result);
30908 exprtk_debug((
"(c0 * v0) * (c1 * v1) --> (covov) (c0 * c1) * v0 * v1\n"));
30910 return (synthesis_result) ? result : error_node();
30915 const bool synthesis_result =
30916 synthesize_sf3ext_expression::
30917 template compile<ctype,vtype,vtype>(expr_gen,
"(t*t)/t", (c0 / c1), v0, v1, result);
30919 exprtk_debug((
"(c0 * v0) / (c1 * v1) --> (covov) (c0 / c1) * (v0 / v1)\n"));
30921 return (synthesis_result) ? result : error_node();
30926 const bool synthesis_result =
30927 synthesize_sf3ext_expression::
30928 template compile<ctype,vtype,vtype>(expr_gen,
"t/(t*t)", (c0 * c1), v0, v1, result);
30930 exprtk_debug((
"(c0 / v0) * (c1 / v1) --> (covov) (c0 * c1) / (v0 * v1)\n"));
30932 return (synthesis_result) ? result : error_node();
30937 const bool synthesis_result =
30938 synthesize_sf3ext_expression::
30939 template compile<ctype,vtype,vtype>(expr_gen,
"(t*t)/t", (c0 / c1), v1, v0, result);
30941 exprtk_debug((
"(c0 / v0) / (c1 / v1) --> (covov) ((c0 / c1) * v1) / v0\n"));
30943 return (synthesis_result) ? result : error_node();
30948 const bool synthesis_result =
30949 synthesize_sf3ext_expression::
30950 template compile<ctype,vtype,vtype>(expr_gen,
"t*(t*t)", (c0 / c1), v0, v1, result);
30952 exprtk_debug((
"(c0 * v0) / (c1 / v1) --> (covov) (c0 / c1) * (v0 * v1)\n"));
30954 return (synthesis_result) ? result : error_node();
30959 const bool synthesis_result =
30960 synthesize_sf3ext_expression::
30961 template compile<ctype,vtype,vtype>(expr_gen,
"t/(t*t)", (c0 / c1), v0, v1, result);
30963 exprtk_debug((
"(c0 / v0) / (c1 * v1) --> (covov) (c0 / c1) / (v0 * v1)\n"));
30965 return (synthesis_result) ? result : error_node();
30969 (std::equal_to<T>()(c0,c1)) &&
30978 std::string specfunc;
30984 default :
return error_node();
30987 const bool synthesis_result =
30988 synthesize_sf3ext_expression::
30989 template compile<ctype, vtype, vtype>(expr_gen, specfunc, c0, v0, v1, result);
30991 exprtk_debug((
"(c * v0) +/- (c * v1) --> (covov) c * (v0 +/- v1)\n"));
30993 return (synthesis_result) ? result : error_node();
30997 const bool synthesis_result =
30998 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
30999 (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, c1, v1, result);
31001 if (synthesis_result)
31003 else if (!expr_gen.valid_operator(o0,f0))
31004 return error_node();
31005 else if (!expr_gen.valid_operator(o1,f1))
31006 return error_node();
31007 else if (!expr_gen.valid_operator(o2,f2))
31008 return error_node();
31010 return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, c1, v1, f0, f1, f2);
31038 const Type c0 = voc0->
c();
31039 const Type& v0 = voc0->
v();
31040 const Type c1 = voc1->
c();
31041 const Type& v1 = voc1->
v();
31060 const bool synthesis_result =
31061 synthesize_sf3ext_expression::
31062 template compile<ctype,vtype,vtype>(expr_gen,
"(t+t)+t", (c0 + c1), v0, v1, result);
31064 exprtk_debug((
"(v0 + c0) + (v1 + c1) --> (covov) (c0 + c1) + v0 + v1\n"));
31066 return (synthesis_result) ? result : error_node();
31071 const bool synthesis_result =
31072 synthesize_sf3ext_expression::
31073 template compile<ctype,vtype,vtype>(expr_gen,
"(t+t)-t", (c0 - c1), v0, v1, result);
31075 exprtk_debug((
"(v0 + c0) - (v1 + c1) --> (covov) (c0 - c1) + v0 - v1\n"));
31077 return (synthesis_result) ? result : error_node();
31082 const bool synthesis_result =
31083 synthesize_sf3ext_expression::
31084 template compile<ctype,vtype,vtype>(expr_gen,
"(t+t)-t", (c1 - c0), v0, v1, result);
31086 exprtk_debug((
"(v0 - c0) - (v1 - c1) --> (covov) (c1 - c0) + v0 - v1\n"));
31088 return (synthesis_result) ? result : error_node();
31093 const bool synthesis_result =
31094 synthesize_sf3ext_expression::
31095 template compile<ctype,vtype,vtype>(expr_gen,
"(t*t)*t", (c0 * c1), v0, v1, result);
31097 exprtk_debug((
"(v0 * c0) * (v1 * c1) --> (covov) (c0 * c1) * v0 * v1\n"));
31099 return (synthesis_result) ? result : error_node();
31104 const bool synthesis_result =
31105 synthesize_sf3ext_expression::
31106 template compile<ctype,vtype,vtype>(expr_gen,
"(t*t)/t", (c0 / c1), v0, v1, result);
31108 exprtk_debug((
"(v0 * c0) / (v1 * c1) --> (covov) (c0 / c1) * (v0 / v1)\n"));
31110 return (synthesis_result) ? result : error_node();
31115 const bool synthesis_result =
31116 synthesize_sf3ext_expression::
31117 template compile<ctype,vtype,vtype>(expr_gen,
"(t*t)*t", Type(1) / (c0 * c1), v0, v1, result);
31119 exprtk_debug((
"(v0 / c0) * (v1 / c1) --> (covov) (1 / (c0 * c1)) * v0 * v1\n"));
31121 return (synthesis_result) ? result : error_node();
31126 const bool synthesis_result =
31127 synthesize_sf3ext_expression::
31128 template compile<ctype,vtype,vtype>(expr_gen,
"(t*t)/t", (c1 / c0), v0, v1, result);
31130 exprtk_debug((
"(v0 / c0) / (v1 / c1) --> (covov) ((c1 / c0) * v0) / v1\n"));
31132 return (synthesis_result) ? result : error_node();
31137 const bool synthesis_result =
31138 synthesize_sf3ext_expression::
31139 template compile<ctype,vtype,vtype>(expr_gen,
"t*(t/t)", (c0 * c1), v0, v1, result);
31141 exprtk_debug((
"(v0 * c0) / (v1 / c1) --> (covov) (c0 * c1) * (v0 / v1)\n"));
31143 return (synthesis_result) ? result : error_node();
31148 const bool synthesis_result =
31149 synthesize_sf3ext_expression::
31150 template compile<ctype,vtype,vtype>(expr_gen,
"t*(t/t)", Type(1) / (c0 * c1), v0, v1, result);
31152 exprtk_debug((
"(v0 / c0) / (v1 * c1) --> (covov) (1 / (c0 * c1)) * v0 / v1\n"));
31154 return (synthesis_result) ? result : error_node();
31159 const bool synthesis_result =
31160 synthesize_sf4ext_expression::
31161 template compile<vtype,ctype,vtype,ctype>(expr_gen,
"(t*t)*(t+t)", v0, T(1) / c0, v1, c1, result);
31163 exprtk_debug((
"(v0 / c0) * (v1 + c1) --> (vocovoc) (v0 * (1 / c0)) * (v1 + c1)\n"));
31165 return (synthesis_result) ? result : error_node();
31170 const bool synthesis_result =
31171 synthesize_sf4ext_expression::
31172 template compile<vtype,ctype,vtype,ctype>(expr_gen,
"(t*t)*(t-t)", v0, T(1) / c0, v1, c1, result);
31174 exprtk_debug((
"(v0 / c0) * (v1 - c1) --> (vocovoc) (v0 * (1 / c0)) * (v1 - c1)\n"));
31176 return (synthesis_result) ? result : error_node();
31180 (std::equal_to<T>()(c0,c1)) &&
31189 std::string specfunc;
31195 default :
return error_node();
31198 const bool synthesis_result =
31199 synthesize_sf3ext_expression::
31200 template compile<ctype,vtype,vtype>(expr_gen, specfunc, c0, v0, v1, result);
31202 exprtk_debug((
"(v0 * c) +/- (v1 * c) --> (covov) c * (v0 +/- v1)\n"));
31204 return (synthesis_result) ? result : error_node();
31208 (std::equal_to<T>()(c0,c1)) &&
31217 std::string specfunc;
31223 default :
return error_node();
31226 const bool synthesis_result =
31227 synthesize_sf3ext_expression::
31228 template compile<vtype,vtype,ctype>(expr_gen, specfunc, v0, v1, c0, result);
31230 exprtk_debug((
"(v0 / c) +/- (v1 / c) --> (vovoc) (v0 +/- v1) / c\n"));
31232 return (synthesis_result) ? result : error_node();
31236 const bool synthesis_result =
31237 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
31238 (expr_gen, id(expr_gen, o0, o1, o2), v0, c0, v1, c1, result);
31240 if (synthesis_result)
31242 else if (!expr_gen.valid_operator(o0,f0))
31243 return error_node();
31244 else if (!expr_gen.valid_operator(o1,f1))
31245 return error_node();
31246 else if (!expr_gen.valid_operator(o2,f2))
31247 return error_node();
31249 return node_type::allocate(*(expr_gen.node_allocator_), v0, c0, v1, c1, f0, f1, f2);
31277 const Type c0 = cov->
c();
31278 const Type& v0 = cov->
v();
31279 const Type c1 = voc->
c();
31280 const Type& v1 = voc->
v();
31299 const bool synthesis_result =
31300 synthesize_sf3ext_expression::
31301 template compile<ctype,vtype,vtype>(expr_gen,
"(t+t)+t", (c0 + c1), v0, v1, result);
31303 exprtk_debug((
"(c0 + v0) + (v1 + c1) --> (covov) (c0 + c1) + v0 + v1\n"));
31305 return (synthesis_result) ? result : error_node();
31310 const bool synthesis_result =
31311 synthesize_sf3ext_expression::
31312 template compile<ctype,vtype,vtype>(expr_gen,
"(t+t)-t", (c0 - c1), v0, v1, result);
31314 exprtk_debug((
"(c0 + v0) - (v1 + c1) --> (covov) (c0 - c1) + v0 - v1\n"));
31316 return (synthesis_result) ? result : error_node();
31321 const bool synthesis_result =
31322 synthesize_sf3ext_expression::
31323 template compile<ctype,vtype,vtype>(expr_gen,
"t-(t+t)", (c0 + c1), v0, v1, result);
31325 exprtk_debug((
"(c0 - v0) - (v1 - c1) --> (covov) (c0 + c1) - v0 - v1\n"));
31327 return (synthesis_result) ? result : error_node();
31332 const bool synthesis_result =
31333 synthesize_sf3ext_expression::
31334 template compile<ctype,vtype,vtype>(expr_gen,
"(t*t)*t", (c0 * c1), v0, v1, result);
31336 exprtk_debug((
"(c0 * v0) * (v1 * c1) --> (covov) (c0 * c1) * v0 * v1\n"));
31338 return (synthesis_result) ? result : error_node();
31343 const bool synthesis_result =
31344 synthesize_sf3ext_expression::
31345 template compile<ctype,vtype,vtype>(expr_gen,
"(t*t)/t", (c0 / c1), v0, v1, result);
31347 exprtk_debug((
"(c0 * v0) / (v1 * c1) --> (covov) (c0 / c1) * (v0 / v1)\n"));
31349 return (synthesis_result) ? result : error_node();
31354 const bool synthesis_result =
31355 synthesize_sf3ext_expression::
31356 template compile<ctype,vtype,vtype>(expr_gen,
"t*(t/t)", (c0 / c1), v1, v0, result);
31358 exprtk_debug((
"(c0 / v0) * (v1 / c1) --> (covov) (c0 / c1) * (v1 / v0)\n"));
31360 return (synthesis_result) ? result : error_node();
31365 const bool synthesis_result =
31366 synthesize_sf3ext_expression::
31367 template compile<ctype,vtype,vtype>(expr_gen,
"t/(t*t)", (c0 * c1), v0, v1, result);
31369 exprtk_debug((
"(c0 / v0) / (v1 / c1) --> (covov) (c0 * c1) / (v0 * v1)\n"));
31371 return (synthesis_result) ? result : error_node();
31376 const bool synthesis_result =
31377 synthesize_sf3ext_expression::
31378 template compile<ctype,vtype,vtype>(expr_gen,
"(t*t)/t", (c0 * c1), v0, v1, result);
31380 exprtk_debug((
"(c0 * v0) / (v1 / c1) --> (covov) (c0 * c1) * (v0 / v1)\n"));
31382 return (synthesis_result) ? result : error_node();
31387 const bool synthesis_result =
31388 synthesize_sf3ext_expression::
31389 template compile<ctype,vtype,vtype>(expr_gen,
"t/(t*t)", (c0 / c1), v0, v1, result);
31391 exprtk_debug((
"(c0 / v0) / (v1 * c1) --> (covov) (c0 / c1) / (v0 * v1)\n"));
31393 return (synthesis_result) ? result : error_node();
31397 (std::equal_to<T>()(c0,c1)) &&
31406 std::string specfunc;
31412 default :
return error_node();
31415 const bool synthesis_result =
31416 synthesize_sf3ext_expression::
31417 template compile<ctype,vtype,vtype>(expr_gen,specfunc, c0, v0, v1, result);
31419 exprtk_debug((
"(c * v0) +/- (v1 * c) --> (covov) c * (v0 +/- v1)\n"));
31421 return (synthesis_result) ? result : error_node();
31425 const bool synthesis_result =
31426 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
31427 (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, v1, c1, result);
31429 if (synthesis_result)
31431 else if (!expr_gen.valid_operator(o0,f0))
31432 return error_node();
31433 else if (!expr_gen.valid_operator(o1,f1))
31434 return error_node();
31435 else if (!expr_gen.valid_operator(o2,f2))
31436 return error_node();
31438 return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, v1, c1, f0, f1, f2);
31466 const Type c0 = voc->
c();
31467 const Type& v0 = voc->
v();
31468 const Type c1 = cov->
c();
31469 const Type& v1 = cov->
v();
31488 const bool synthesis_result =
31489 synthesize_sf3ext_expression::
31490 template compile<ctype,vtype,vtype>(expr_gen,
"(t+t)+t", (c0 + c1), v0, v1, result);
31492 exprtk_debug((
"(v0 + c0) + (c1 + v1) --> (covov) (c0 + c1) + v0 + v1\n"));
31494 return (synthesis_result) ? result : error_node();
31499 const bool synthesis_result =
31500 synthesize_sf3ext_expression::
31501 template compile<ctype,vtype,vtype>(expr_gen,
"(t+t)-t", (c0 - c1), v0, v1, result);
31503 exprtk_debug((
"(v0 + c0) - (c1 + v1) --> (covov) (c0 - c1) + v0 - v1\n"));
31505 return (synthesis_result) ? result : error_node();
31510 const bool synthesis_result =
31511 synthesize_sf3ext_expression::
31512 template compile<vtype,vtype,ctype>(expr_gen,
"(t+t)-t", v0, v1, (c1 + c0), result);
31514 exprtk_debug((
"(v0 - c0) - (c1 - v1) --> (vovoc) v0 + v1 - (c1 + c0)\n"));
31516 return (synthesis_result) ? result : error_node();
31521 const bool synthesis_result =
31522 synthesize_sf3ext_expression::
31523 template compile<ctype,vtype,vtype>(expr_gen,
"(t*t)*t", (c0 * c1), v0, v1, result);
31525 exprtk_debug((
"(v0 * c0) * (c1 * v1) --> (covov) (c0 * c1) * v0 * v1\n"));
31527 return (synthesis_result) ? result : error_node();
31532 const bool synthesis_result =
31533 synthesize_sf3ext_expression::
31534 template compile<ctype,vtype,vtype>(expr_gen,
"(t*t)/t", (c0 / c1), v0, v1, result);
31536 exprtk_debug((
"(v0 * c0) / (c1 * v1) --> (covov) (c0 / c1) * (v0 * v1)\n"));
31538 return (synthesis_result) ? result : error_node();
31543 const bool synthesis_result =
31544 synthesize_sf3ext_expression::
31545 template compile<ctype,vtype,vtype>(expr_gen,
"(t*t)/t", (c1 / c0), v0, v1, result);
31547 exprtk_debug((
"(v0 / c0) * (c1 / v1) --> (covov) (c1 / c0) * (v0 / v1)\n"));
31549 return (synthesis_result) ? result : error_node();
31554 const bool synthesis_result =
31555 synthesize_sf3ext_expression::
31556 template compile<ctype,vtype,vtype>(expr_gen,
"(t*t)*t", (c0 / c1), v0, v1, result);
31558 exprtk_debug((
"(v0 * c0) / (c1 / v1) --> (covov) (c0 / c1) * (v0 * v1)\n"));
31560 return (synthesis_result) ? result : error_node();
31565 const bool synthesis_result =
31566 synthesize_sf3ext_expression::
31567 template compile<ctype,vtype,vtype>(expr_gen,
"(t*t)/t", Type(1) / (c0 * c1), v0, v1, result);
31569 exprtk_debug((
"(v0 / c0) / (c1 * v1) --> (covov) (1 / (c0 * c1)) * (v0 / v1)\n"));
31571 return (synthesis_result) ? result : error_node();
31576 const bool synthesis_result =
31577 synthesize_sf3ext_expression::
31578 template compile<vtype,vtype,ctype>(expr_gen,
"(t*t)*t", v0, v1, Type(1) / (c0 * c1), result);
31580 exprtk_debug((
"(v0 / c0) / (c1 / v1) --> (vovoc) (v0 * v1) * (1 / (c0 * c1))\n"));
31582 return (synthesis_result) ? result : error_node();
31586 (std::equal_to<T>()(c0,c1)) &&
31594 std::string specfunc;
31600 default :
return error_node();
31603 const bool synthesis_result =
31604 synthesize_sf3ext_expression::
31605 template compile<ctype,vtype,vtype>(expr_gen, specfunc, c0, v0, v1, result);
31607 exprtk_debug((
"(v0 * c) +/- (c * v1) --> (covov) c * (v0 +/- v1)\n"));
31609 return (synthesis_result) ? result : error_node();
31613 const bool synthesis_result =
31614 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
31615 (expr_gen, id(expr_gen, o0, o1, o2), v0, c0, c1, v1, result);
31617 if (synthesis_result)
31619 else if (!expr_gen.valid_operator(o0,f0))
31620 return error_node();
31621 else if (!expr_gen.valid_operator(o1,f1))
31622 return error_node();
31623 else if (!expr_gen.valid_operator(o2,f2))
31624 return error_node();
31626 return node_type::allocate(*(expr_gen.node_allocator_), v0, c0, c1, v1, f0, f1, f2);
31654 const lcl_vovov_t* vovov =
static_cast<const lcl_vovov_t*
>(branch[1]);
31656 const Type& v1 = vovov->t0();
31657 const Type& v2 = vovov->t1();
31658 const Type& v3 = vovov->t2();
31671 if (synthesize_sf4ext_expression::template compile<T0,T1,T2,T3>(expr_gen,
id(expr_gen,o0,o1,o2),v0,v1,v2,v3,result))
31674 return error_node();
31678 return node_type::allocate(*(expr_gen.
node_allocator_),v0,v1,v2,v3,f0,f1,f2);
31706 const lcl_vovoc_t* vovoc =
static_cast<const lcl_vovoc_t*
>(branch[1]);
31708 const Type& v1 = vovoc->t0();
31709 const Type& v2 = vovoc->t1();
31710 const Type c = vovoc->t2();
31723 const bool synthesis_result =
31724 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
31725 (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, v2, c, result);
31727 if (synthesis_result)
31729 else if (!expr_gen.valid_operator(o0,f0))
31730 return error_node();
31734 return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, c, f0, f1, f2);
31762 const lcl_vocov_t* vocov =
static_cast<const lcl_vocov_t*
>(branch[1]);
31764 const Type& v1 = vocov->t0();
31765 const Type c = vocov->t1();
31766 const Type& v2 = vocov->t2();
31779 const bool synthesis_result =
31780 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
31781 (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, c, v2, result);
31783 if (synthesis_result)
31785 if (!expr_gen.valid_operator(o0,f0))
31786 return error_node();
31790 return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, c, v2, f0, f1, f2);
31818 const lcl_covov_t* covov =
static_cast<const lcl_covov_t*
>(branch[1]);
31820 const Type c = covov->t0();
31821 const Type& v1 = covov->t1();
31822 const Type& v2 = covov->t2();
31835 const bool synthesis_result =
31836 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
31837 (expr_gen, id(expr_gen, o0, o1, o2), v0, c, v1, v2, result);
31839 if (synthesis_result)
31841 else if (!expr_gen.valid_operator(o0,f0))
31842 return error_node();
31846 return node_type::allocate(*(expr_gen.node_allocator_), v0, c, v1, v2, f0, f1, f2);
31874 const lcl_vovov_t* vovov =
static_cast<const lcl_vovov_t*
>(branch[1]);
31876 const Type& v0 = vovov->t0();
31877 const Type& v1 = vovov->t1();
31878 const Type& v2 = vovov->t2();
31892 const bool synthesis_result =
31893 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
31894 (expr_gen, id(expr_gen, o0, o1, o2), c, v0, v1, v2, result);
31896 if (synthesis_result)
31898 if (!expr_gen.valid_operator(o0,f0))
31899 return error_node();
31903 return node_type::allocate(*(expr_gen.node_allocator_), c, v0, v1, v2, f0, f1, f2);
31931 const lcl_vocov_t* vocov =
static_cast<const lcl_vocov_t*
>(branch[1]);
31933 const Type& v0 = vocov->t0();
31934 const Type c1 = vocov->t1();
31935 const Type& v1 = vocov->t2();
31949 const bool synthesis_result =
31950 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
31951 (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, c1, v1, result);
31953 if (synthesis_result)
31955 else if (!expr_gen.valid_operator(o0,f0))
31956 return error_node();
31960 return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, c1, v1, f0, f1, f2);
31988 const lcl_covoc_t* covoc =
static_cast<const lcl_covoc_t*
>(branch[1]);
31990 const Type c0 = covoc->t0();
31991 const Type& v1 = covoc->t1();
31992 const Type c1 = covoc->t2();
32005 const bool synthesis_result =
32006 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
32007 (expr_gen, id(expr_gen, o0, o1, o2), v0, c0, v1, c1, result);
32009 if (synthesis_result)
32011 else if (!expr_gen.valid_operator(o0,f0))
32012 return error_node();
32016 return node_type::allocate(*(expr_gen.node_allocator_), v0, c0, v1, c1, f0, f1, f2);
32043 const lcl_vovoc_t* vovoc =
static_cast<const lcl_vovoc_t*
>(branch[1]);
32045 const Type& v0 = vovoc->t0();
32046 const Type& v1 = vovoc->t1();
32047 const Type c1 = vovoc->t2();
32061 const bool synthesis_result =
32062 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
32063 (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, v1, c1, result);
32065 if (synthesis_result)
32067 else if (!expr_gen.valid_operator(o0,f0))
32068 return error_node();
32072 return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, v1, c1, f0, f1, f2);
32100 const lcl_cocov_t* cocov =
static_cast<const lcl_cocov_t*
>(branch[1]);
32102 const Type c0 = cocov->t0();
32103 const Type c1 = cocov->t1();
32104 const Type& v1 = cocov->t2();
32117 const bool synthesis_result =
32118 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
32119 (expr_gen, id(expr_gen, o0, o1, o2), v0, c0, c1, v1, result);
32121 if (synthesis_result)
32123 else if (!expr_gen.valid_operator(o0,f0))
32124 return error_node();
32128 return node_type::allocate(*(expr_gen.node_allocator_), v0, c0, c1, v1, f0, f1, f2);
32156 const lcl_vovov_t* vovov =
static_cast<const lcl_vovov_t*
>(branch[1]);
32158 const Type& v1 = vovov->t0();
32159 const Type& v2 = vovov->t1();
32160 const Type& v3 = vovov->t2();
32173 const bool synthesis_result =
32174 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
32175 (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, v2, v3, result);
32177 if (synthesis_result)
32179 else if (!expr_gen.valid_operator(o0,f0))
32180 return error_node();
32184 return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, v3, f0, f1, f2);
32212 const lcl_vovoc_t* vovoc =
static_cast<const lcl_vovoc_t*
>(branch[1]);
32214 const Type& v1 = vovoc->t0();
32215 const Type& v2 = vovoc->t1();
32216 const Type c = vovoc->t2();
32229 const bool synthesis_result =
32230 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
32231 (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, v2, c, result);
32233 if (synthesis_result)
32235 else if (!expr_gen.valid_operator(o0,f0))
32236 return error_node();
32240 return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, c, f0, f1, f2);
32268 const lcl_vocov_t* vocov =
static_cast<const lcl_vocov_t*
>(branch[1]);
32270 const Type& v1 = vocov->t0();
32271 const Type c = vocov->t1();
32272 const Type& v2 = vocov->t2();
32285 const bool synthesis_result =
32286 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
32287 (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, c, v2, result);
32289 if (synthesis_result)
32291 else if (!expr_gen.valid_operator(o0,f0))
32292 return error_node();
32296 return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, c, v2, f0, f1, f2);
32324 const lcl_covov_t* covov =
static_cast<const lcl_covov_t*
>(branch[1]);
32326 const Type c = covov->t0();
32327 const Type& v1 = covov->t1();
32328 const Type& v2 = covov->t2();
32341 const bool synthesis_result =
32342 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
32343 (expr_gen, id(expr_gen, o0, o1, o2), v0, c, v1, v2, result);
32345 if (synthesis_result)
32347 else if (!expr_gen.valid_operator(o0,f0))
32348 return error_node();
32352 return node_type::allocate(*(expr_gen.node_allocator_), v0, c, v1, v2, f0, f1, f2);
32380 const lcl_vovov_t* vovov =
static_cast<const lcl_vovov_t*
>(branch[1]);
32382 const Type& v0 = vovov->t0();
32383 const Type& v1 = vovov->t1();
32384 const Type& v2 = vovov->t2();
32398 const bool synthesis_result =
32399 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
32400 (expr_gen, id(expr_gen, o0, o1, o2), c, v0, v1, v2, result);
32402 if (synthesis_result)
32404 else if (!expr_gen.valid_operator(o0,f0))
32405 return error_node();
32409 return node_type::allocate(*(expr_gen.node_allocator_), c, v0, v1, v2, f0, f1, f2);
32437 const lcl_vocov_t* vocov =
static_cast<const lcl_vocov_t*
>(branch[1]);
32439 const Type& v0 = vocov->t0();
32440 const Type c1 = vocov->t1();
32441 const Type& v1 = vocov->t2();
32455 const bool synthesis_result =
32456 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
32457 (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, c1, v1, result);
32459 if (synthesis_result)
32461 else if (!expr_gen.valid_operator(o0,f0))
32462 return error_node();
32466 return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, c1, v1, f0, f1, f2);
32494 const lcl_covoc_t* covoc =
static_cast<const lcl_covoc_t*
>(branch[1]);
32496 const Type c0 = covoc->t0();
32497 const Type& v1 = covoc->t1();
32498 const Type c1 = covoc->t2();
32511 const bool synthesis_result =
32512 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
32513 (expr_gen, id(expr_gen, o0, o1, o2), v0, c0, v1, c1, result);
32515 if (synthesis_result)
32517 else if (!expr_gen.valid_operator(o0,f0))
32518 return error_node();
32522 return node_type::allocate(*(expr_gen.node_allocator_), v0, c0, v1, c1, f0, f1, f2);
32550 const lcl_vovoc_t* vovoc =
static_cast<const lcl_vovoc_t*
>(branch[1]);
32552 const Type& v0 = vovoc->t0();
32553 const Type& v1 = vovoc->t1();
32554 const Type c1 = vovoc->t2();
32568 const bool synthesis_result =
32569 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
32570 (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, v1, c1, result);
32572 if (synthesis_result)
32574 else if (!expr_gen.valid_operator(o0,f0))
32575 return error_node();
32579 return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, v1, c1, f0, f1, f2);
32597 exprtk_debug((
"v0 o0 ((c0 o1 c1) o2 v1) - Not possible\n"));
32598 return error_node();
32624 const lcl_vovov_t* vovov =
static_cast<const lcl_vovov_t*
>(branch[0]);
32625 const Type& v0 = vovov->
t0();
32626 const Type& v1 = vovov->t1();
32627 const Type& v2 = vovov->t2();
32641 const bool synthesis_result =
32642 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
32643 (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, v2, v3, result);
32645 if (synthesis_result)
32647 else if (!expr_gen.valid_operator(o2,f2))
32648 return error_node();
32652 return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, v3, f0, f1, f2);
32680 const lcl_vovov_t* vovov =
static_cast<const lcl_vovov_t*
>(branch[0]);
32681 const Type& v0 = vovov->
t0();
32682 const Type& v1 = vovov->t1();
32683 const Type& v2 = vovov->t2();
32698 const bool synthesis_result =
32699 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
32700 (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, v2, c, result);
32702 if (synthesis_result)
32704 else if (!expr_gen.valid_operator(o2,f2))
32705 return error_node();
32709 return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, c, f0, f1, f2);
32737 const lcl_vovoc_t* vovoc =
static_cast<const lcl_vovoc_t*
>(branch[0]);
32738 const Type& v0 = vovoc->
t0();
32739 const Type& v1 = vovoc->t1();
32740 const Type c = vovoc->t2();
32754 const bool synthesis_result =
32755 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
32756 (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, c, v2, result);
32758 if (synthesis_result)
32760 else if (!expr_gen.valid_operator(o2,f2))
32761 return error_node();
32765 return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, c, v2, f0, f1, f2);
32793 const lcl_vocov_t* vocov =
static_cast<const lcl_vocov_t*
>(branch[0]);
32794 const Type& v0 = vocov->
t0();
32795 const Type c = vocov->t1();
32796 const Type& v1 = vocov->t2();
32810 const bool synthesis_result =
32811 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
32812 (expr_gen, id(expr_gen, o0, o1, o2), v0, c, v1, v2, result);
32814 if (synthesis_result)
32816 else if (!expr_gen.valid_operator(o2,f2))
32817 return error_node();
32821 return node_type::allocate(*(expr_gen.node_allocator_), v0, c, v1, v2, f0, f1, f2);
32849 const lcl_covov_t* covov =
static_cast<const lcl_covov_t*
>(branch[0]);
32850 const Type c = covov->
t0();
32851 const Type& v0 = covov->t1();
32852 const Type& v1 = covov->t2();
32866 const bool synthesis_result =
32867 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
32868 (expr_gen, id(expr_gen, o0, o1, o2), c, v0, v1, v2, result);
32870 if (synthesis_result)
32872 else if (!expr_gen.valid_operator(o2,f2))
32873 return error_node();
32877 return node_type::allocate(*(expr_gen.node_allocator_), c, v0, v1, v2, f0, f1, f2);
32905 const lcl_covoc_t* covoc =
static_cast<const lcl_covoc_t*
>(branch[0]);
32906 const Type c0 = covoc->
t0();
32907 const Type& v0 = covoc->t1();
32908 const Type c1 = covoc->t2();
32922 const bool synthesis_result =
32923 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
32924 (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, c1, v1, result);
32926 if (synthesis_result)
32928 else if (!expr_gen.valid_operator(o2,f2))
32929 return error_node();
32933 return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, c1, v1, f0, f1, f2);
32961 const lcl_vocov_t* vocov =
static_cast<const lcl_vocov_t*
>(branch[0]);
32962 const Type& v0 = vocov->
t0();
32963 const Type c0 = vocov->t1();
32964 const Type& v1 = vocov->t2();
32979 const bool synthesis_result =
32980 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
32981 (expr_gen, id(expr_gen, o0, o1, o2), v0, c0, v1, c1, result);
32983 if (synthesis_result)
32985 else if (!expr_gen.valid_operator(o2,f2))
32986 return error_node();
32990 return node_type::allocate(*(expr_gen.node_allocator_), v0, c0, v1, c1, f0, f1, f2);
33018 const lcl_covov_t* covov =
static_cast<const lcl_covov_t*
>(branch[0]);
33019 const Type c0 = covov->
t0();
33020 const Type& v0 = covov->t1();
33021 const Type& v1 = covov->t2();
33036 const bool synthesis_result =
33037 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
33038 (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, v1, c1, result);
33040 if (synthesis_result)
33042 else if (!expr_gen.valid_operator(o2,f2))
33043 return error_node();
33047 return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, v1, c1, f0, f1, f2);
33075 const lcl_vococ_t* vococ =
static_cast<const lcl_vococ_t*
>(branch[0]);
33076 const Type& v0 = vococ->
t0();
33077 const Type c0 = vococ->t1();
33078 const Type c1 = vococ->t2();
33092 const bool synthesis_result =
33093 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
33094 (expr_gen, id(expr_gen, o0, o1, o2), v0, c0, c1, v1, result);
33096 if (synthesis_result)
33098 else if (!expr_gen.valid_operator(o2,f2))
33099 return error_node();
33103 return node_type::allocate(*(expr_gen.node_allocator_), v0, c0, c1, v1, f0, f1, f2);
33131 const lcl_vovov_t* vovov =
static_cast<const lcl_vovov_t*
>(branch[0]);
33132 const Type& v0 = vovov->
t0();
33133 const Type& v1 = vovov->t1();
33134 const Type& v2 = vovov->t2();
33148 const bool synthesis_result =
33149 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
33150 (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, v2, v3, result);
33152 if (synthesis_result)
33154 else if (!expr_gen.valid_operator(o2,f2))
33155 return error_node();
33159 return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, v3, f0, f1, f2);
33187 const lcl_vovov_t* vovov =
static_cast<const lcl_vovov_t*
>(branch[0]);
33188 const Type& v0 = vovov->
t0();
33189 const Type& v1 = vovov->t1();
33190 const Type& v2 = vovov->t2();
33205 const bool synthesis_result =
33206 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
33207 (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, v2, c, result);
33209 if (synthesis_result)
33211 else if (!expr_gen.valid_operator(o2,f2))
33212 return error_node();
33216 return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, c, f0, f1, f2);
33244 const lcl_vovoc_t* vovoc =
static_cast<const lcl_vovoc_t*
>(branch[0]);
33245 const Type& v0 = vovoc->
t0();
33246 const Type& v1 = vovoc->t1();
33247 const Type c = vovoc->t2();
33261 const bool synthesis_result =
33262 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
33263 (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, c, v2, result);
33265 if (synthesis_result)
33267 else if (!expr_gen.valid_operator(o2,f2))
33268 return error_node();
33272 return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, c, v2, f0, f1, f2);
33300 const lcl_vocov_t* vocov =
static_cast<const lcl_vocov_t*
>(branch[0]);
33301 const Type& v0 = vocov->
t0();
33302 const Type c = vocov->t1();
33303 const Type& v1 = vocov->t2();
33316 const bool synthesis_result =
33317 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
33318 (expr_gen, id(expr_gen, o0, o1, o2), v0, c, v1, v2, result);
33320 if (synthesis_result)
33322 else if (!expr_gen.valid_operator(o2,f2))
33323 return error_node();
33327 return node_type::allocate(*(expr_gen.node_allocator_), v0, c, v1, v2, f0, f1, f2);
33355 const lcl_covov_t* covov =
static_cast<const lcl_covov_t*
>(branch[0]);
33356 const Type c = covov->
t0();
33357 const Type& v0 = covov->t1();
33358 const Type& v1 = covov->t2();
33372 const bool synthesis_result =
33373 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
33374 (expr_gen, id(expr_gen, o0, o1, o2), c, v0, v1, v2, result);
33376 if (synthesis_result)
33378 else if (!expr_gen.valid_operator(o2,f2))
33379 return error_node();
33383 return node_type::allocate(*(expr_gen.node_allocator_), c, v0, v1, v2, f0, f1, f2);
33411 const lcl_covoc_t* covoc =
static_cast<const lcl_covoc_t*
>(branch[0]);
33412 const Type c0 = covoc->
t0();
33413 const Type& v0 = covoc->t1();
33414 const Type c1 = covoc->t2();
33428 const bool synthesis_result =
33429 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
33430 (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, c1, v1, result);
33432 if (synthesis_result)
33434 else if (!expr_gen.valid_operator(o2,f2))
33435 return error_node();
33439 return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, c1, v1, f0, f1, f2);
33467 const lcl_vocov_t* vocov =
static_cast<const lcl_vocov_t*
>(branch[0]);
33468 const Type& v0 = vocov->
t0();
33469 const Type c0 = vocov->t1();
33470 const Type& v1 = vocov->t2();
33485 const bool synthesis_result =
33486 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
33487 (expr_gen, id(expr_gen, o0, o1, o2), v0, c0, v1, c1, result);
33489 if (synthesis_result)
33491 else if (!expr_gen.valid_operator(o2,f2))
33492 return error_node();
33496 return node_type::allocate(*(expr_gen.node_allocator_), v0, c0, v1, c1, f0, f1, f2);
33524 const lcl_covov_t* covov =
static_cast<const lcl_covov_t*
>(branch[0]);
33525 const Type c0 = covov->
t0();
33526 const Type& v0 = covov->t1();
33527 const Type& v1 = covov->t2();
33542 const bool synthesis_result =
33543 synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
33544 (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, v1, c1, result);
33546 if (synthesis_result)
33548 else if (!expr_gen.valid_operator(o2,f2))
33549 return error_node();
33553 return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, v1, c1, f0, f1, f2);
33571 exprtk_debug((
"((v0 o0 (c0 o1 c1)) o2 v1) - Not possible\n"));
33572 return error_node();
33594 if (!valid_operator(o0,u0))
33595 return error_node();
33596 else if (!valid_operator(o1,u1))
33597 return error_node();
33598 else if (!valid_operator(operation,f))
33599 return error_node();
33645 result = node_allocator_->
33646 allocate_rrrrr<typename details::uvouv_node<Type> >(v0, v1, u0, u1, f);
33653 #undef basic_opr_switch_statements
33654 #undef extended_opr_switch_statements
33655 #undef unary_opr_switch_statements
33657 #ifndef exprtk_disable_string_capabilities
33659 #define string_opr_switch_statements \
33660 case_stmt(details:: e_lt ,details:: lt_op) \
33661 case_stmt(details:: e_lte ,details:: lte_op) \
33662 case_stmt(details:: e_gt ,details:: gt_op) \
33663 case_stmt(details:: e_gte ,details:: gte_op) \
33664 case_stmt(details:: e_eq ,details:: eq_op) \
33665 case_stmt(details:: e_ne ,details:: ne_op) \
33666 case_stmt(details::e_in ,details:: in_op) \
33667 case_stmt(details::e_like ,details:: like_op) \
33668 case_stmt(details::e_ilike,details::ilike_op) \
33670 template <
typename T0,
typename T1>
33677 #define case_stmt(op0,op1) \
33678 case op0 : return node_allocator_-> \
33679 allocate_ttt<typename details::str_xrox_node<Type,T0,T1,range_t,op1<Type> >,T0,T1> \
33684 default :
return error_node();
33688 template <
typename T0,
typename T1>
33695 #define case_stmt(op0,op1) \
33696 case op0 : return node_allocator_-> \
33697 allocate_ttt<typename details::str_xoxr_node<Type,T0,T1,range_t,op1<Type> >,T0,T1> \
33702 default :
return error_node();
33706 template <
typename T0,
typename T1>
33713 #define case_stmt(op0,op1) \
33714 case op0 : return node_allocator_-> \
33715 allocate_tttt<typename details::str_xroxr_node<Type,T0,T1,range_t,op1<Type> >,T0,T1> \
33716 (s0, s1, rp0, rp1); \
33720 default :
return error_node();
33724 template <
typename T0,
typename T1>
33729 #define case_stmt(op0,op1) \
33730 case op0 : return node_allocator_-> \
33731 allocate_tt<typename details::sos_node<Type,T0,T1,op1<Type> >,T0,T1>(s0, s1); \
33735 default :
return error_node();
33744 return synthesize_sos_expression_impl<std::string&,std::string&>(opr, s0, s1);
33757 return synthesize_str_xrox_expression_impl<std::string&,std::string&>(opr, s0, s1, rp0);
33770 return synthesize_str_xoxr_expression_impl<std::string&,std::string&>(opr, s0, s1, rp1);
33783 return synthesize_str_xoxr_expression_impl<std::string&, const std::string>(opr, s0, s1, rp1);
33799 return synthesize_str_xroxr_expression_impl<std::string&,std::string&>(opr, s0, s1, rp0, rp1);
33809 return synthesize_sos_expression_impl<std::string&, const std::string>(opr, s0, s1);
33819 return synthesize_sos_expression_impl<const std::string,std::string&>(opr, s0, s1);
33833 return synthesize_str_xoxr_expression_impl<const std::string,std::string&>(opr, s0, s1, rp1);
33847 return synthesize_str_xrox_expression_impl<std::string&, const std::string>(opr, s0, s1, rp0);
33863 return synthesize_str_xroxr_expression_impl<std::string&, const std::string>(opr, s0, s1, rp0, rp1);
33883 expression_node_ptr temp = synthesize_sos_expression_impl<const std::string, const std::string>(opr, s0, s1);
33885 const Type
v = temp->
value();
33908 return synthesize_str_xoxr_expression_impl<const std::string, const std::string>(opr, s0, s1, rp1);
33921 return synthesize_str_xrox_expression_impl<const std::string,std::string&>(opr, s0, s1, rp0);
33937 return synthesize_str_xroxr_expression_impl<const std::string,std::string&>(opr, s0, s1, rp0, rp1);
33950 return synthesize_str_xrox_expression_impl<const std::string,std::string>(opr, s0, s1, rp0);
33965 return synthesize_str_xroxr_expression_impl<const std::string, const std::string>(opr, s0, s1, rp0, rp1);
33972 #define case_stmt(op0,op1) \
33973 case op0 : return node_allocator_-> \
33974 allocate_ttt<typename details::str_sogens_node<Type,op1<Type> > > \
33975 (opr, branch[0], branch[1]); \
33979 default :
return error_node();
33984 #ifndef exprtk_disable_string_capabilities
33987 if ((0 == branch[0]) || (0 == branch[1]))
33991 return error_node();
34022 if (!b0_is_cs || !b1_is_cs)
34024 return synthesize_expression<string_concat_node_t,2>(opr,branch);
34028 if (b0_is_gen || b1_is_gen)
34030 return synthesize_strogen_expression(opr,branch);
34034 if (b1_is_s )
return synthesize_sos_expression (opr,branch);
34035 else if (b1_is_cs )
return synthesize_socs_expression (opr,branch);
34036 else if (b1_is_sr )
return synthesize_sosr_expression (opr,branch);
34037 else if (b1_is_csr)
return synthesize_socsr_expression (opr,branch);
34041 if (b1_is_s )
return synthesize_csos_expression (opr,branch);
34042 else if (b1_is_cs )
return synthesize_csocs_expression (opr,branch);
34043 else if (b1_is_sr )
return synthesize_csosr_expression (opr,branch);
34044 else if (b1_is_csr)
return synthesize_csocsr_expression(opr,branch);
34048 if (b1_is_s )
return synthesize_sros_expression (opr,branch);
34049 else if (b1_is_sr )
return synthesize_srosr_expression (opr,branch);
34050 else if (b1_is_cs )
return synthesize_srocs_expression (opr,branch);
34051 else if (b1_is_csr)
return synthesize_srocsr_expression(opr,branch);
34053 else if (b0_is_csr)
34055 if (b1_is_s )
return synthesize_csros_expression (opr,branch);
34056 else if (b1_is_sr )
return synthesize_csrosr_expression (opr,branch);
34057 else if (b1_is_cs )
return synthesize_csrocs_expression (opr,branch);
34058 else if (b1_is_csr)
return synthesize_csrocsr_expression(opr,branch);
34061 return error_node();
34067 return error_node();
34071 #ifndef exprtk_disable_string_capabilities
34075 return error_node();
34076 else if ((0 == branch[0]) || (0 == branch[1]) || (0 == branch[2]))
34080 return error_node();
34092 const Type
v = (((s0 <= s1) && (s1 <= s2)) ? Type(1) : Type(0));
34110 return node_allocator_->allocate_type<inrange_t,std::string&,std::string&,std::string&>(s0,s1,s2);
34127 return node_allocator_->allocate_type<inrange_t,std::string,std::string&,std::string>(s0,s1,s2);
34143 return node_allocator_->allocate_type<inrange_t,std::string&,std::string,std::string&>(s0,s1,s2);
34159 return node_allocator_->allocate_type<inrange_t,std::string&,std::string&,std::string>(s0,s1,s2);
34175 return node_allocator_->allocate_type<inrange_t,std::string,std::string&,std::string&>(s0,s1,s2);
34178 return error_node();
34184 return error_node();
34206 if (b0_null && b1_null)
34230 allocate_rc<nulleq_node_t>(branch[b0_null ? 0 : 1],
true);
34239 allocate_rc<nulleq_node_t>(branch[b0_null ? 0 : 1],
false);
34248 branch[0] = branch[1];
34249 branch[1] = error_node();
34254 branch[1] = error_node();
34283 template <
typename NodeType, std::
size_t N>
34294 return error_node();
34296 else if (!details::all_nodes_valid<N>(branch))
34300 return error_node();
34305 expression_node_ptr expression_point = node_allocator_->allocate<NodeType>(operation,branch);
34307 if (is_constant_foldable<N>(branch))
34309 Type
v = expression_point->
value();
34315 return expression_point;
34318 return error_node();
34321 template <
typename NodeType, std::
size_t N>
34324 if (!details::all_nodes_valid<N>(branch))
34328 return error_node();
34336 function_N_node_t* func_node_ptr =
dynamic_cast<function_N_node_t*
>(expression_point);
34338 if (0 == func_node_ptr)
34342 return error_node();
34345 func_node_ptr->init_branches(branch);
34349 Type
v = expression_point->
value();
34355 parser_->state_.activate_side_effect(
"synthesize_expression(function<NT,N>)");
34357 return expression_point;
34373 error_list_.push_back(error_type);
34378 if (!error_list_.empty())
34380 error_list_.pop_back();
34386 if (synthesis_error_.empty())
34388 synthesis_error_ = synthesis_error_message;
34394 for (std::size_t i = 0; i < sem_.size(); ++i)
34399 (scope_element::e_variable == se.
type) ||
34400 (scope_element::e_vecelem == se.
type)
34413 else if (scope_element::e_vector == se.
type)
34425 #ifndef exprtk_disable_string_capabilities
34426 else if (scope_element::e_string == se.
type)
34442 #ifndef exprtk_disable_string_capabilities
34454 results_context_ = 0;
34459 #define register_unary_op(Op,UnaryFunctor) \
34460 m.insert(std::make_pair(Op,UnaryFunctor<T>::process)); \
34501 #undef register_unary_op
34506 typedef typename binary_op_map_t::value_type value_type;
34508 #define register_binary_op(Op,BinaryFunctor) \
34509 m.insert(value_type(Op,BinaryFunctor<T>::process)); \
34529 #undef register_binary_op
34534 typedef typename inv_binary_op_map_t::value_type value_type;
34536 #define register_binary_op(Op,BinaryFunctor) \
34537 m.insert(value_type(BinaryFunctor<T>::process,Op)); \
34557 #undef register_binary_op
34562 typedef std::pair<trinary_functor_t,details::operator_type> pair_t;
34564 #define register_sf3(Op) \
34565 sf3_map[details::sf##Op##_op<T>::id()] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \
34575 #undef register_sf3
34577 #define register_sf3_extid(Id, Op) \
34578 sf3_map[Id] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \
34581 #undef register_sf3_extid
34586 typedef std::pair<quaternary_functor_t,details::operator_type> pair_t;
34588 #define register_sf4(Op) \
34589 sf4_map[details::sf##Op##_op<T>::id()] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \
34600 #undef register_sf4
34602 #define register_sf4ext(Op) \
34603 sf4_map[details::sfext##Op##_op<T>::id()] = pair_t(details::sfext##Op##_op<T>::process,details::e_sf4ext##Op); \
34621 #undef register_sf4ext
34626 if (0 == results_context_)
34631 return (*results_context_);
34636 #ifndef exprtk_disable_return_statement
34637 if (results_context_)
34639 delete results_context_;
34640 results_context_ = 0;
34643 state_.return_stmt_present =
false;
34683 template <
typename ParserType>
34687 template <
typename Allocator,
34688 template <
typename,
typename>
class Sequence>
34690 Sequence<std::string, Allocator>& symbol_list)
34696 typedef parser_t::dependent_entity_collector::symbol_t symbol_t;
34698 symbol_table_t symbol_table;
34704 parser.enable_unknown_symbol_resolver();
34705 parser.dec().collect_variables() =
true;
34707 if (!parser.compile(expr_str, expression))
34710 std::deque<symbol_t> symb_list;
34712 parser.dec().symbols(symb_list);
34714 for (std::size_t i = 0; i < symb_list.size(); ++i)
34716 symbol_list.push_back(symb_list[i].first);
34722 template <
typename T,
34723 typename Allocator,
34724 template <
typename,
typename>
class Sequence>
34727 Sequence<std::string, Allocator>& symbol_list)
34732 typedef typename parser_t::dependent_entity_collector::symbol_t symbol_t;
34734 symbol_table_t symbol_table;
34739 expression.register_symbol_table(extrnl_symbol_table);
34741 parser.enable_unknown_symbol_resolver();
34742 parser.dec().collect_variables() =
true;
34746 if (!parser.compile(expr_str, expression))
34749 std::deque<symbol_t> symb_list;
34751 parser.dec().symbols(symb_list);
34753 for (std::size_t i = 0; i < symb_list.size(); ++i)
34755 symbol_list.push_back(symb_list[i].first);
34761 template <
typename Allocator,
34762 template <
typename,
typename>
class Sequence>
34764 Sequence<std::string, Allocator>& symbol_list)
34770 typedef parser_t::dependent_entity_collector::symbol_t symbol_t;
34772 symbol_table_t symbol_table;
34778 parser.enable_unknown_symbol_resolver();
34779 parser.dec().collect_functions() =
true;
34781 if (!parser.compile(expr_str, expression))
34784 std::deque<symbol_t> symb_list;
34786 parser.dec().symbols(symb_list);
34788 for (std::size_t i = 0; i < symb_list.size(); ++i)
34790 symbol_list.push_back(symb_list[i].first);
34796 template <
typename T,
34797 typename Allocator,
34798 template <
typename,
typename>
class Sequence>
34801 Sequence<std::string, Allocator>& symbol_list)
34806 typedef typename parser_t::dependent_entity_collector::symbol_t symbol_t;
34808 symbol_table_t symbol_table;
34813 expression.register_symbol_table(extrnl_symbol_table);
34815 parser.enable_unknown_symbol_resolver();
34816 parser.dec().collect_functions() =
true;
34820 if (!parser.compile(expr_str, expression))
34823 std::deque<symbol_t> symb_list;
34825 parser.dec().symbols(symb_list);
34827 for (std::size_t i = 0; i < symb_list.size(); ++i)
34829 symbol_list.push_back(symb_list[i].first);
34835 template <
typename T>
34838 const T& r0,
const T& r1,
34839 const std::size_t number_of_intervals = 1000000)
34844 const T h = (r1 - r0) / (T(2) * number_of_intervals);
34845 T total_area = T(0);
34847 for (std::size_t i = 0; i < number_of_intervals; ++i)
34849 x = r0 + T(2) * i * h;
34850 const T y0 = e.
value(); x += h;
34851 const T y1 = e.
value(); x += h;
34852 const T y2 = e.
value(); x += h;
34853 total_area += h * (y0 + T(4) * y1 + y2) / T(3);
34859 template <
typename T>
34861 const std::string& variable_name,
34862 const T& r0,
const T& r1,
34863 const std::size_t number_of_intervals = 1000000)
34867 if (!sym_table.
valid())
34868 return std::numeric_limits<T>::quiet_NaN();
34876 T result =
integrate(e,x,r0,r1,number_of_intervals);
34882 return std::numeric_limits<T>::quiet_NaN();
34885 template <
typename T>
34888 const T& h = T(0.00000001))
34890 const T x_init =
x;
34891 const T _2h = T(2) * h;
34894 const T y0 = e.
value();
34896 const T y1 = e.
value();
34898 const T y2 = e.
value();
34900 const T y3 = e.
value();
34903 return (-y0 + T(8) * (y1 - y2) + y3) / (T(12) * h);
34906 template <
typename T>
34909 const T& h = T(0.00001))
34911 const T x_init =
x;
34912 const T _2h = T(2) * h;
34914 const T y = e.
value();
34916 const T y0 = e.
value();
34918 const T y1 = e.
value();
34920 const T y2 = e.
value();
34922 const T y3 = e.
value();
34925 return (-y0 + T(16) * (y1 + y2) - T(30) * y - y3) / (T(12) * h * h);
34928 template <
typename T>
34931 const T& h = T(0.0001))
34933 const T x_init =
x;
34934 const T _2h = T(2) * h;
34937 const T y0 = e.
value();
34939 const T y1 = e.
value();
34941 const T y2 = e.
value();
34943 const T y3 = e.
value();
34946 return (y0 + T(2) * (y2 - y1) - y3) / (T(2) * h * h * h);
34949 template <
typename T>
34951 const std::string& variable_name,
34952 const T& h = T(0.00000001))
34956 if (!sym_table.
valid())
34958 return std::numeric_limits<T>::quiet_NaN();
34973 return std::numeric_limits<T>::quiet_NaN();
34976 template <
typename T>
34978 const std::string& variable_name,
34979 const T& h = T(0.00001))
34983 if (!sym_table.
valid())
34985 return std::numeric_limits<T>::quiet_NaN();
34993 const T x_original =
x;
35000 return std::numeric_limits<T>::quiet_NaN();
35003 template <
typename T>
35005 const std::string& variable_name,
35006 const T& h = T(0.0001))
35010 if (!sym_table.
valid())
35012 return std::numeric_limits<T>::quiet_NaN();
35020 const T x_original =
x;
35027 return std::numeric_limits<T>::quiet_NaN();
35040 template <
typename T>
35041 inline bool compute(
const std::string& expression_string, T& result)
35052 if (parser.compile(expression_string,expression))
35054 result = expression.
value();
35062 template <
typename T>
35063 inline bool compute(
const std::string& expression_string,
35068 static const std::string x_var(
"x");
35079 if (parser.compile(expression_string,expression))
35081 result = expression.
value();
35089 template <
typename T>
35090 inline bool compute(
const std::string& expression_string,
35091 const T&x,
const T& y,
35095 static const std::string x_var(
"x");
35096 static const std::string y_var(
"y");
35108 if (parser.compile(expression_string,expression))
35110 result = expression.
value();
35118 template <
typename T>
35119 inline bool compute(
const std::string& expression_string,
35120 const T& x,
const T& y,
const T& z,
35124 static const std::string x_var(
"x");
35125 static const std::string y_var(
"y");
35126 static const std::string z_var(
"z");
35139 if (parser.compile(expression_string,expression))
35141 result = expression.
value();
35149 template <
typename T, std::
size_t N>
35154 template <
typename Type, std::
size_t NumberOfCoefficients>
35157 template <
typename Type>
35161 const Type c12,
const Type c11,
const Type c10,
const Type c9,
const Type c8,
35162 const Type c7,
const Type c6,
const Type c5,
const Type c4,
const Type c3,
35163 const Type c2,
const Type c1,
const Type c0)
35166 return ((((((((((((c12 * x + c11) * x + c10) * x + c9) * x + c8) * x + c7) * x + c6) * x + c5) * x + c4) * x + c3) * x + c2) * x + c1) * x + c0);
35170 template <
typename Type>
35174 const Type c11,
const Type c10,
const Type c9,
const Type c8,
const Type c7,
35175 const Type c6,
const Type c5,
const Type c4,
const Type c3,
const Type c2,
35176 const Type c1,
const Type c0)
35179 return (((((((((((c11 * x + c10) * x + c9) * x + c8) * x + c7) * x + c6) * x + c5) * x + c4) * x + c3) * x + c2) * x + c1) * x + c0);
35183 template <
typename Type>
35187 const Type c10,
const Type c9,
const Type c8,
const Type c7,
const Type c6,
35188 const Type c5,
const Type c4,
const Type c3,
const Type c2,
const Type c1,
35192 return ((((((((((c10 * x + c9) * x + c8) * x + c7) * x + c6) * x + c5) * x + c4) * x + c3) * x + c2) * x + c1) * x + c0);
35196 template <
typename Type>
35200 const Type c9,
const Type c8,
const Type c7,
const Type c6,
const Type c5,
35201 const Type c4,
const Type c3,
const Type c2,
const Type c1,
const Type c0)
35204 return (((((((((c9 * x + c8) * x + c7) * x + c6) * x + c5) * x + c4) * x + c3) * x + c2) * x + c1) * x + c0);
35208 template <
typename Type>
35212 const Type c8,
const Type c7,
const Type c6,
const Type c5,
const Type c4,
35213 const Type c3,
const Type c2,
const Type c1,
const Type c0)
35216 return ((((((((c8 * x + c7) * x + c6) * x + c5) * x + c4) * x + c3) * x + c2) * x + c1) * x + c0);
35220 template <
typename Type>
35224 const Type c7,
const Type c6,
const Type c5,
const Type c4,
const Type c3,
35225 const Type c2,
const Type c1,
const Type c0)
35228 return (((((((c7 * x + c6) * x + c5) * x + c4) * x + c3) * x + c2) * x + c1) * x + c0);
35232 template <
typename Type>
35236 const Type c6,
const Type c5,
const Type c4,
const Type c3,
const Type c2,
35237 const Type c1,
const Type c0)
35240 return ((((((c6 * x + c5) * x + c4) * x + c3) * x + c2) * x + c1) * x + c0);
35244 template <
typename Type>
35248 const Type c5,
const Type c4,
const Type c3,
const Type c2,
35249 const Type c1,
const Type c0)
35252 return (((((c5 * x + c4) * x + c3) * x + c2) * x + c1) * x + c0);
35256 template <
typename Type>
35259 static inline T
evaluate(
const Type x,
const Type c4,
const Type c3,
const Type c2,
const Type c1,
const Type c0)
35262 return ((((c4 * x + c3) * x + c2) * x + c1) * x + c0);
35266 template <
typename Type>
35269 static inline T
evaluate(
const Type x,
const Type c3,
const Type c2,
const Type c1,
const Type c0)
35272 return (((c3 * x + c2) * x + c1) * x + c0);
35276 template <
typename Type>
35279 static inline T
evaluate(
const Type x,
const Type c2,
const Type c1,
const Type c0)
35282 return ((c2 * x + c1) * x + c0);
35286 template <
typename Type>
35289 static inline T
evaluate(
const Type x,
const Type c1,
const Type c0)
35292 return (c1 * x + c0);
35301 :
ifunction<T>((N+2 <= 20) ? (N + 2) : std::numeric_limits<std::size_t>::
max())
35309 #define poly_rtrn(NN) \
35310 return (NN != N) ? std::numeric_limits<T>::quiet_NaN() :
35312 inline virtual T operator() (
const T& x,
const T& c1,
const T& c0)
35317 inline virtual T operator() (
const T& x,
const T& c2,
const T& c1,
const T& c0)
35322 inline virtual T operator() (
const T& x,
const T& c3,
const T& c2,
const T& c1,
const T& c0)
35327 inline virtual T operator() (
const T& x,
const T& c4,
const T& c3,
const T& c2,
const T& c1,
const T& c0)
35332 inline virtual T operator() (
const T& x,
const T& c5,
const T& c4,
const T& c3,
const T& c2,
const T& c1,
const T& c0)
35337 inline virtual T operator() (
const T& x,
const T& c6,
const T& c5,
const T& c4,
const T& c3,
const T& c2,
const T& c1,
const T& c0)
35342 inline virtual T operator() (
const T& x,
const T& c7,
const T& c6,
const T& c5,
const T& c4,
const T& c3,
const T& c2,
const T& c1,
const T& c0)
35347 inline virtual T operator() (
const T& x,
const T& c8,
const T& c7,
const T& c6,
const T& c5,
const T& c4,
const T& c3,
const T& c2,
const T& c1,
const T& c0)
35349 poly_rtrn(8)
poly_impl<T,8>::evaluate(x,c8,c7,c6,c5,c4,c3,c2,c1,c0);
35352 inline virtual T operator() (
const T& x,
const T& c9,
const T& c8,
const T& c7,
const T& c6,
const T& c5,
const T& c4,
const T& c3,
const T& c2,
const T& c1,
const T& c0)
35354 poly_rtrn(9)
poly_impl<T,9>::evaluate(x,c9,c8,c7,c6,c5,c4,c3,c2,c1,c0);
35357 inline virtual T operator() (
const T& x,
const T& c10,
const T& c9,
const T& c8,
const T& c7,
const T& c6,
const T& c5,
const T& c4,
const T& c3,
const T& c2,
const T& c1,
const T& c0)
35359 poly_rtrn(10)
poly_impl<T,10>::evaluate(x,c10,c9,c8,c7,c6,c5,c4,c3,c2,c1,c0);
35362 inline virtual T operator() (
const T& x,
const T& c11,
const T& c10,
const T& c9,
const T& c8,
const T& c7,
const T& c6,
const T& c5,
const T& c4,
const T& c3,
const T& c2,
const T& c1,
const T& c0)
35364 poly_rtrn(11)
poly_impl<T,11>::evaluate(x,c11,c10,c9,c8,c7,c6,c5,c4,c3,c2,c1,c0);
35367 inline virtual T operator() (
const T& x,
const T& c12,
const T& c11,
const T& c10,
const T& c9,
const T& c8,
const T& c7,
const T& c6,
const T& c5,
const T& c4,
const T& c3,
const T& c2,
const T& c1,
const T& c0)
35369 poly_rtrn(12)
poly_impl<T,12>::evaluate(x,c12,c11,c10,c9,c8,c7,c6,c5,c4,c3,c2,c1,c0);
35374 inline virtual T operator() ()
35376 return std::numeric_limits<T>::quiet_NaN();
35379 inline virtual T operator() (
const T&)
35381 return std::numeric_limits<T>::quiet_NaN();
35384 inline virtual T operator() (
const T&,
const T&)
35386 return std::numeric_limits<T>::quiet_NaN();
35390 template <
typename T>
35391 class function_compositor
35405 function(
const std::string& n)
35417 const std::string& v0)
35426 const std::string& v0,
const std::string& v1)
35430 v_.push_back(v0); v_.push_back(v1);
35435 const std::string& v0,
const std::string& v1,
35436 const std::string& v2)
35440 v_.push_back(v0); v_.push_back(v1);
35446 const std::string& v0,
const std::string& v1,
35447 const std::string& v2,
const std::string& v3)
35451 v_.push_back(v0); v_.push_back(v1);
35452 v_.push_back(v2); v_.push_back(v3);
35457 const std::string& v0,
const std::string& v1,
35458 const std::string& v2,
const std::string& v3,
35459 const std::string& v4)
35463 v_.push_back(v0); v_.push_back(v1);
35464 v_.push_back(v2); v_.push_back(v3);
35468 inline function&
name(
const std::string& n)
35480 inline function&
var(
const std::string&
v)
35506 local_var_stack_size(0),
35522 (*
v[0]) = v0; (*
v[1]) = v1;
35525 inline void update(
const T& v0,
const T& v1,
const T& v2)
35527 (*
v[0]) = v0; (*
v[1]) = v1;
35531 inline void update(
const T& v0,
const T& v1,
const T& v2,
const T& v3)
35533 (*
v[0]) = v0; (*
v[1]) = v1;
35534 (*
v[2]) = v2; (*
v[3]) = v3;
35537 inline void update(
const T& v0,
const T& v1,
const T& v2,
const T& v3,
const T& v4)
35539 (*
v[0]) = v0; (*
v[1]) = v1;
35540 (*
v[2]) = v2; (*
v[3]) = v3;
35544 inline void update(
const T& v0,
const T& v1,
const T& v2,
const T& v3,
const T& v4,
const T& v5)
35546 (*
v[0]) = v0; (*
v[1]) = v1;
35547 (*
v[2]) = v2; (*
v[3]) = v3;
35548 (*
v[4]) = v4; (*
v[5]) = v5;
35555 typedef typename expression_t::control_block::local_data_list_t ldl_t;
35559 std::vector<std::size_t> index_list;
35561 for (std::size_t i = 0; i < ldl.size(); ++i)
35565 index_list.push_back(i);
35569 std::size_t input_param_count = 0;
35571 for (std::size_t i = 0; i < index_list.size(); ++i)
35573 const std::size_t index = index_list[i];
35575 if (i < (index_list.size() -
v.size()))
35579 reinterpret_cast<T*>(ldl[index].pointer),
35582 local_var_stack_size += ldl[index].size;
35585 v[input_param_count++] =
reinterpret_cast<T*
>(ldl[index].pointer);
35599 var_t var_stack(
v.size(),T(0));
35601 param_stack.push_back(var_stack);
35606 var_t local_var_stack(local_var_stack_size,T(0));
35607 copy(lv,local_var_stack);
35608 local_stack.push_back(local_var_stack);
35619 copy(param_stack.back(),
v);
35620 param_stack.pop_back();
35625 copy(local_stack.back(),lv);
35626 local_stack.pop_back();
35633 for (std::size_t i = 0; i < src_v.size(); ++i)
35635 dest_v[i] = (*src_v[i]);
35641 for (std::size_t i = 0; i < src_v.size(); ++i)
35643 (*dest_v[i]) = src_v[i];
35649 typename var_t::iterator itr = dest_v.begin();
35650 typedef typename std::iterator_traits<typename var_t::iterator>::difference_type diff_t;
35652 for (std::size_t i = 0; i < src_v.size(); ++i)
35656 if (1 == vr.second)
35657 *itr++ = (*vr.first);
35660 std::copy(vr.first, vr.first + vr.second, itr);
35661 itr +=
static_cast<diff_t
>(vr.second);
35668 typename var_t::const_iterator itr = src_v.begin();
35669 typedef typename std::iterator_traits<typename var_t::iterator>::difference_type diff_t;
35671 for (std::size_t i = 0; i < src_v.size(); ++i)
35675 if (1 == vr.second)
35676 (*vr.first) = *itr++;
35679 std::copy(itr, itr + static_cast<diff_t>(vr.second), vr.first);
35680 itr +=
static_cast<diff_t
>(vr.second);
35687 for (std::size_t i = 0; i <
v.size(); ++i)
35715 inline T operator() ()
35717 return this->
value(base_func::expression);
35723 template <
typename BaseFuncType>
35746 base_func::update(v0);
35747 return this->
value(base_func::expression);
35760 base_func::update(v0, v1);
35761 return this->
value(base_func::expression);
35774 base_func::update(v0, v1, v2);
35775 return this->
value(base_func::expression);
35788 base_func::update(v0, v1, v2, v3);
35789 return this->
value(base_func::expression);
35802 base_func::update(v0, v1, v2, v3, v4);
35803 return this->
value(base_func::expression);
35816 base_func::update(v0, v1, v2, v3, v4, v5);
35817 return this->
value(base_func::expression);
35824 typedef typename results_context_t::type_store_t type_t;
35825 typedef typename type_t::scalar_view scalar_t;
35827 T result = e.
value();
35834 return scalar_t(e.
results()[0])();
35840 #define def_fp_retval(N) \
35841 struct func_##N##param_retval : public func_##N##param \
35843 inline T value(expression_t& e) \
35845 return return_value(e); \
35857 template <typename Allocator,
35858 template <typename,typename> class Sequence>
35859 inline
bool add(const std::
string&
name,
35861 const Sequence<std::
string,Allocator>& var_list,
35862 const
bool override = false)
35864 const typename std::map<std::string,expression_t>::iterator itr = expr_map_.find(name);
35866 if (expr_map_.end() != itr)
35870 exprtk_debug((
"Compositor error(add): function '%s' already defined\n",
35876 remove(
name, var_list.size());
35879 if (compile_expression(name,expression,var_list))
35881 const std::size_t n = var_list.size();
35883 fp_map_[n][
name]->setup(expr_map_[name]);
35889 exprtk_debug((
"Compositor error(add): Failed to compile function '%s'\n",
35905 : symbol_table_(st),
35918 return symbol_table_;
35923 auxiliary_symtab_list_.push_back(&symtab);
35928 symbol_table_.clear();
35929 expr_map_ .clear();
35931 for (std::size_t i = 0; i < fp_map_.size(); ++i)
35933 typename funcparam_t::iterator itr = fp_map_[i].begin();
35934 typename funcparam_t::iterator end = fp_map_[i].end ();
35938 delete itr->second;
35942 fp_map_[i].clear();
35946 inline bool add(
const function& f,
const bool override =
false)
35948 return add(f.name_, f.expression_, f.v_,
override);
35953 template <
typename Allocator,
35954 template <
typename,
typename>
class Sequence>
35957 const Sequence<std::string,Allocator>& input_var_list,
35958 bool return_present =
false)
35963 local_symbol_table.
load_from(symbol_table_);
35966 if (!valid(name,input_var_list.size()))
35970 input_var_list.size(),
35971 local_symbol_table,
35977 for (std::size_t i = 0; i < auxiliary_symtab_list_.size(); ++i)
35982 std::string mod_expression;
35984 for (std::size_t i = 0; i < input_var_list.size(); ++i)
35986 mod_expression +=
" var " + input_var_list[i] +
"{};\n";
35993 mod_expression +=
"~" + expression +
";";
35995 mod_expression +=
"~{" + expression +
"};";
35997 if (!parser_.compile(mod_expression,compiled_expression))
35999 exprtk_debug((
"Compositor Error: %s\n",parser_.error().c_str()));
36000 exprtk_debug((
"Compositor modified expression: \n%s\n",mod_expression.c_str()));
36002 remove(
name,input_var_list.size());
36007 if (!return_present && parser_.dec().return_present())
36009 remove(
name,input_var_list.size());
36011 return compile_expression(name, expression, input_var_list,
true);
36015 if (parser_.dec().return_present())
36017 typedef std::vector<std::string> str_list_t;
36019 str_list_t ret_param_list = parser_.dec().return_param_type_list();
36021 for (std::size_t i = 0; i < ret_param_list.size(); ++i)
36023 const std::string& params = ret_param_list[i];
36025 if (params.empty() || (
'T' != params[0]))
36027 exprtk_debug((
"Compositor Error: Return statement in function '%s' is invalid\n",
36030 remove(
name,input_var_list.size());
36037 expr_map_[
name] = compiled_expression;
36041 if (symbol_table_.add_function(name,ifunc))
36045 exprtk_debug((
"Compositor Error: Failed to add function '%s' to symbol table\n",
36054 symbol_table_.is_variable (symbol) ||
36055 symbol_table_.is_stringvar (symbol) ||
36056 symbol_table_.is_function (symbol) ||
36057 symbol_table_.is_vector (symbol) ||
36058 symbol_table_.is_vararg_function(symbol)
36063 const std::size_t& arg_count)
const
36067 else if (symbol_used(name))
36069 else if (fp_map_[arg_count].end() != fp_map_[arg_count].find(name))
36076 const std::size_t& arg_count,
36078 const bool ret_present =
false)
36082 #define case_stmt(N) \
36083 case N : (fp_map_[arg_count])[name] = \
36084 (!ret_present) ? static_cast<base_func*> \
36085 (new func_##N##param) : \
36086 static_cast<base_func*> \
36087 (new func_##N##param_retval) ; \
36101 inline void remove(
const std::string&
name,
const std::size_t& arg_count)
36106 const typename std::map<std::string,expression_t>::iterator em_itr = expr_map_.find(
name);
36108 if (expr_map_.end() != em_itr)
36110 expr_map_.erase(em_itr);
36113 const typename funcparam_t::iterator fp_itr = fp_map_[arg_count].find(
name);
36115 if (fp_map_[arg_count].end() != fp_itr)
36117 delete fp_itr->second;
36118 fp_map_[arg_count].erase(fp_itr);
36121 symbol_table_.remove_function(
name);
36133 template <
typename T>
36136 static const std::string expression_list[]
36141 "(y + x / y) * (x - y / x)",
36142 "x / ((x + y) * (x - y)) / y",
36143 "1 - ((x * y) + (y / x)) - 3",
36144 "sin(2 * x) + cos(pi / y)",
36145 "1 - sin(2 * x) + cos(pi / y)",
36146 "sqrt(1 - sin(2 * x) + cos(pi / y) / 3)",
36147 "(x^2 / sin(2 * pi / y)) -x / 2",
36148 "x + (cos(y - sin(2 / x * pi)) - sin(x - cos(2 * y / pi))) - y",
36149 "clamp(-1.0, sin(2 * pi * x) + cos(y / 2 * pi), +1.0)",
36150 "iclamp(-1.0, sin(2 * pi * x) + cos(y / 2 * pi), +1.0)",
36151 "max(3.33, min(sqrt(1 - sin(2 * x) + cos(pi / y) / 3), 1.11))",
36152 "if(avg(x,y) <= x + y, x - y, x * y) + 2 * pi / x",
36153 "1.1x^1 + 2.2y^2 - 3.3x^3 + 4.4y^4 - 5.5x^5 + 6.6y^6 - 7.7x^27 + 8.8y^55",
36156 "(2 * yy + 2 * xx)",
36157 "(yy + xx / yy) * (xx - yy / xx)",
36158 "xx / ((xx + yy) * (xx - yy)) / yy",
36159 "1 - ((xx * yy) + (yy / xx)) - 3",
36160 "sin(2 * xx) + cos(pi / yy)",
36161 "1 - sin(2 * xx) + cos(pi / yy)",
36162 "sqrt(1 - sin(2 * xx) + cos(pi / yy) / 3)",
36163 "(xx^2 / sin(2 * pi / yy)) -xx / 2",
36164 "xx + (cos(yy - sin(2 / xx * pi)) - sin(xx - cos(2 * yy / pi))) - yy",
36165 "clamp(-1.0, sin(2 * pi * xx) + cos(yy / 2 * pi), +1.0)",
36166 "max(3.33, min(sqrt(1 - sin(2 * xx) + cos(pi / yy) / 3), 1.11))",
36167 "if(avg(xx,yy) <= xx + yy, xx - yy, xx * yy) + 2 * pi / xx",
36168 "1.1xx^1 + 2.2yy^2 - 3.3xx^3 + 4.4yy^4 - 5.5xx^5 + 6.6yy^6 - 7.7xx^27 + 8.8yy^55",
36169 "(1.1*(2.2*(3.3*(4.4*(5.5*(6.6*(7.7*(8.8*(9.9+x)))))))))",
36170 "(((((((((x+9.9)*8.8)*7.7)*6.6)*5.5)*4.4)*3.3)*2.2)*1.1)",
36171 "(x + y) * z",
"x + (y * z)",
"(x + y) * 7",
"x + (y * 7)",
36172 "(x + 7) * y",
"x + (7 * y)",
"(7 + x) * y",
"7 + (x * y)",
36173 "(2 + x) * 3",
"2 + (x * 3)",
"(2 + 3) * x",
"2 + (3 * x)",
36174 "(x + 2) * 3",
"x + (2 * 3)",
36175 "(x + y) * (z / w)",
"(x + y) * (z / 7)",
"(x + y) * (7 / z)",
"(x + 7) * (y / z)",
36176 "(7 + x) * (y / z)",
"(2 + x) * (y / z)",
"(x + 2) * (y / 3)",
"(2 + x) * (y / 3)",
36177 "(x + 2) * (3 / y)",
"x + (y * (z / w))",
"x + (y * (z / 7))",
"x + (y * (7 / z))",
36178 "x + (7 * (y / z))",
"7 + (x * (y / z))",
"2 + (x * (3 / y))",
"x + (2 * (y / 4))",
36179 "2 + (x * (y / 3))",
"x + (2 * (3 / y))",
36180 "x + ((y * z) / w)",
"x + ((y * z) / 7)",
"x + ((y * 7) / z)",
"x + ((7 * y) / z)",
36181 "7 + ((y * z) / w)",
"2 + ((x * 3) / y)",
"x + ((2 * y) / 3)",
"2 + ((x * y) / 3)",
36182 "x + ((2 * 3) / y)",
"(((x + y) * z) / w)",
36183 "(((x + y) * z) / 7)",
"(((x + y) * 7) / z)",
"(((x + 7) * y) / z)",
"(((7 + x) * y) / z)",
36184 "(((2 + x) * 3) / y)",
"(((x + 2) * y) / 3)",
"(((2 + x) * y) / 3)",
"(((x + 2) * 3) / y)",
36185 "((x + (y * z)) / w)",
"((x + (y * z)) / 7)",
"((x + (y * 7)) / y)",
"((x + (7 * y)) / z)",
36186 "((7 + (x * y)) / z)",
"((2 + (x * 3)) / y)",
"((x + (2 * y)) / 3)",
"((2 + (x * y)) / 3)",
36187 "((x + (2 * 3)) / y)",
36188 "(xx + yy) * zz",
"xx + (yy * zz)",
36189 "(xx + yy) * 7",
"xx + (yy * 7)",
36190 "(xx + 7) * yy",
"xx + (7 * yy)",
36191 "(7 + xx) * yy",
"7 + (xx * yy)",
36192 "(2 + x) * 3",
"2 + (x * 3)",
36193 "(2 + 3) * x",
"2 + (3 * x)",
36194 "(x + 2) * 3",
"x + (2 * 3)",
36195 "(xx + yy) * (zz / ww)",
"(xx + yy) * (zz / 7)",
36196 "(xx + yy) * (7 / zz)",
"(xx + 7) * (yy / zz)",
36197 "(7 + xx) * (yy / zz)",
"(2 + xx) * (yy / zz)",
36198 "(xx + 2) * (yy / 3)",
"(2 + xx) * (yy / 3)",
36199 "(xx + 2) * (3 / yy)",
"xx + (yy * (zz / ww))",
36200 "xx + (yy * (zz / 7))",
"xx + (yy * (7 / zz))",
36201 "xx + (7 * (yy / zz))",
"7 + (xx * (yy / zz))",
36202 "2 + (xx * (3 / yy))",
"xx + (2 * (yy / 4))",
36203 "2 + (xx * (yy / 3))",
"xx + (2 * (3 / yy))",
36204 "xx + ((yy * zz) / ww)",
"xx + ((yy * zz) / 7)",
36205 "xx + ((yy * 7) / zz)",
"xx + ((7 * yy) / zz)",
36206 "7 + ((yy * zz) / ww)",
"2 + ((xx * 3) / yy)",
36207 "xx + ((2 * yy) / 3)",
"2 + ((xx * yy) / 3)",
36208 "xx + ((2 * 3) / yy)",
"(((xx + yy) * zz) / ww)",
36209 "(((xx + yy) * zz) / 7)",
"(((xx + yy) * 7) / zz)",
36210 "(((xx + 7) * yy) / zz)",
"(((7 + xx) * yy) / zz)",
36211 "(((2 + xx) * 3) / yy)",
"(((xx + 2) * yy) / 3)",
36212 "(((2 + xx) * yy) / 3)",
"(((xx + 2) * 3) / yy)",
36213 "((xx + (yy * zz)) / ww)",
"((xx + (yy * zz)) / 7)",
36214 "((xx + (yy * 7)) / yy)",
"((xx + (7 * yy)) / zz)",
36215 "((7 + (xx * yy)) / zz)",
"((2 + (xx * 3)) / yy)",
36216 "((xx + (2 * yy)) / 3)",
"((2 + (xx * yy)) / 3)",
36217 "((xx + (2 * 3)) / yy)"
36219 static const std::size_t expression_list_size =
sizeof(expression_list) /
sizeof(std::string);
36241 typedef typename std::deque<exprtk::expression<T> > expr_list_t;
36242 expr_list_t expr_list;
36244 const std::size_t rounds = 50;
36247 for (std::size_t r = 0; r < rounds; ++r)
36252 for (std::size_t i = 0; i < expression_list_size; ++i)
36257 if (!parser.
compile(expression_list[i],expression))
36262 expr_list.push_back(expression);
36271 static const T lower_bound = T(-20);
36272 static const T upper_bound = T(+20);
36273 static const T delta = T(0.1);
36277 for (x = lower_bound; x <= upper_bound; x += delta)
36279 for (y = lower_bound; y <= upper_bound; y += delta)
36281 total += expression.
value();
36289 for (std::size_t i = 0; i < expr_list.size(); ++i)
36296 for (std::size_t i = 0; i < 10000; ++i)
36298 const T
v = T(123.456 + i);
36303 #define else_stmt(N) \
36304 else if (details::is_true(details::numeric::nequal(details::numeric::fast_exp<T,N>::result(v),details::numeric::pow(v,T(N))))) \
36329 #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
36333 # ifndef WIN32_LEAN_AND_MEAN
36334 # define WIN32_LEAN_AND_MEAN
36336 # include <windows.h>
36340 # include <sys/time.h>
36341 # include <sys/types.h>
36350 #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
36354 QueryPerformanceFrequency(&clock_frequency_);
36357 inline void start()
36369 inline double time()
const
36429 #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
36432 LARGE_INTEGER clock_frequency_;
36441 #ifndef exprtk_disable_rtl_io
36444 namespace rtl {
namespace io {
namespace details
36446 template <
typename T>
36451 printf(fmt.c_str(),
v);
36454 template <
typename T>
36466 for (std::size_t i = 0; i < parameters.
size(); ++i)
36481 default :
continue;
36493 for (std::size_t i = 0; i < v.
size(); ++i)
36497 if ((i + 1) < v.
size())
36504 printf(
"%s",
to_str(s).c_str());
36510 template <
typename T>
36517 print(
const std::string& scalar_format =
"%10.5f")
36532 template <
typename T>
36555 template <
typename T>
36563 #define exprtk_register_function(FunctionName,FunctionType) \
36564 if (!symtab.add_function(FunctionName,FunctionType)) \
36567 "exprtk::rtl::io::register_package - Failed to add function: %s\n", \
36574 #undef exprtk_register_function
36585 #ifndef exprtk_disable_rtl_io_file
36589 namespace rtl {
namespace io {
namespace file {
namespace details
36615 std::ifstream* stream =
new std::ifstream(
file_name.c_str(),std::ios::binary);
36631 std::ofstream* stream =
new std::ofstream(
file_name.c_str(),std::ios::binary);
36647 std::fstream* stream =
new std::fstream(
file_name.c_str(),std::ios::binary);
36665 template <
typename Stream,
typename Ptr>
36668 Stream* stream =
reinterpret_cast<Stream*
>(p);
36671 p =
reinterpret_cast<Ptr
>(0);
36687 default :
return false;
36693 template <
typename View>
36694 bool write(
const View& view,
const std::size_t amount,
const std::size_t offset = 0)
36699 write(reinterpret_cast<const char*>(view.begin() + offset), amount *
sizeof(
typename View::value_t));
36703 write(reinterpret_cast<const char*>(view.begin() + offset) , amount *
sizeof(
typename View::value_t));
36706 default :
return false;
36712 template <
typename View>
36713 bool read(View& view,
const std::size_t amount,
const std::size_t offset = 0)
36718 read(reinterpret_cast<char*>(view.begin() + offset), amount *
sizeof(
typename View::value_t));
36722 read(reinterpret_cast<char*>(view.begin() + offset) , amount *
sizeof(
typename View::value_t));
36725 default :
return false;
36735 case e_read :
return (!!std::getline(*reinterpret_cast<std::ifstream*>(
stream_ptr),s));
36736 case e_rdwrt :
return (!!std::getline(*reinterpret_cast<std::fstream* >(
stream_ptr),s));
36737 default :
return false;
36748 default :
return true;
36754 if (access.empty() || access.size() > 2)
36757 std::size_t w_cnt = 0;
36758 std::size_t r_cnt = 0;
36760 for (std::size_t i = 0; i < access.size(); ++i)
36762 switch (std::tolower(access[i]))
36764 case 'r' : r_cnt++;
break;
36765 case 'w' : w_cnt++;
break;
36770 if ((0 == r_cnt) && (0 == w_cnt))
36772 else if ((r_cnt > 1) || (w_cnt > 1))
36774 else if ((1 == r_cnt) && (1 == w_cnt))
36776 else if (1 == r_cnt)
36783 template <
typename T>
36788 std::memcpy(reinterpret_cast<char*>(&fd),
36789 reinterpret_cast<const char*>(&v),
36794 template <
typename T>
36798 #pragma warning(push)
36799 #pragma warning(disable: 4127)
36801 if (
sizeof(T) <
sizeof(
void*))
36803 throw std::runtime_error(
"exprtk::rtl::io::file - Error - pointer size larger than holder.");
36806 #pragma warning(pop)
36812 template <
typename T>
36826 { details::perform_check<T>(); }
36830 std::string file_name;
36831 std::string access;
36835 if (file_name.empty())
36851 std::memcpy(reinterpret_cast<char*>(&t ),
36852 reinterpret_cast<char*>(&fd),
36864 template <
typename T>
36871 { details::perform_check<T>(); }
36886 template <
typename T>
36902 { details::perform_check<T>(); }
36908 std::size_t amount = 0;
36913 const string_t buffer(parameters[1]);
36914 amount = buffer.
size();
36915 return T(fd->
write(buffer,amount) ? 1 : 0);
36919 const string_t buffer(parameters[1]);
36921 static_cast<std::size_t
>(
scalar_t(parameters[2])()));
36922 return T(fd->
write(buffer,amount) ? 1 : 0);
36926 const vector_t vec(parameters[1]);
36927 amount = vec.
size();
36928 return T(fd->
write(vec,amount) ? 1 : 0);
36932 const vector_t vec(parameters[1]);
36934 static_cast<std::size_t
>(
scalar_t(parameters[2])()));
36935 return T(fd->
write(vec,amount) ? 1 : 0);
36943 template <
typename T>
36959 { details::perform_check<T>(); }
36965 std::size_t amount = 0;
36971 amount = buffer.
size();
36972 return T(fd->
read(buffer,amount) ? 1 : 0);
36978 static_cast<std::size_t
>(
scalar_t(parameters[2])()));
36979 return T(fd->
read(buffer,amount) ? 1 : 0);
36984 amount = vec.
size();
36985 return T(fd->
read(vec,amount) ? 1 : 0);
36991 static_cast<std::size_t
>(
scalar_t(parameters[2])()));
36992 return T(fd->
read(vec,amount) ? 1 : 0);
37000 template <
typename T>
37015 { details::perform_check<T>(); }
37021 return T(fd->
getline(result) ? 1 : 0);
37025 template <
typename T>
37032 { details::perform_check<T>(); }
37038 return (fd->
eof() ? T(1) : T(0));
37042 template <
typename T>
37054 #define exprtk_register_function(FunctionName,FunctionType) \
37055 if (!symtab.add_function(FunctionName,FunctionType)) \
37058 "exprtk::rtl::io::file::register_package - Failed to add function: %s\n", \
37069 #undef exprtk_register_function
37081 #ifndef exprtk_disable_rtl_vecops
37084 namespace rtl {
namespace vecops {
37088 template <
typename Vector>
37091 if (r0 > (v.size() - 1))
37093 else if (r1 > (v.size() - 1))
37101 template <
typename T>
37111 std::size_t& r0, std::size_t& r1,
37112 const std::size_t& r0_prmidx,
37113 const std::size_t& r1_prmidx,
37114 const std::size_t vec_idx = 0)
37116 if (r0_prmidx >= parameters.
size())
37119 if (r1_prmidx >= parameters.
size())
37135 template <
typename T>
37140 error = (y - sum) - x;
37146 template <
typename T>
37169 const vector_t vec(parameters[0]);
37171 std::size_t r0 = 0;
37172 std::size_t r1 = vec.
size() - 1;
37178 return std::numeric_limits<T>::quiet_NaN();
37180 for (std::size_t i = r0; i <= r1; ++i)
37182 if (vec[i] == T(0))
37192 template <
typename T>
37215 const vector_t vec(parameters[0]);
37217 std::size_t r0 = 0;
37218 std::size_t r1 = vec.
size() - 1;
37224 return std::numeric_limits<T>::quiet_NaN();
37226 for (std::size_t i = r0; i <= r1; ++i)
37228 if (vec[i] != T(0))
37238 template <
typename T>
37261 const vector_t vec(parameters[0]);
37263 std::size_t r0 = 0;
37264 std::size_t r1 = vec.
size() - 1;
37270 return std::numeric_limits<T>::quiet_NaN();
37272 for (std::size_t i = r0; i <= r1; ++i)
37274 if (vec[i] != T(0))
37284 template <
typename T>
37307 const vector_t vec(parameters[0]);
37309 std::size_t r0 = 0;
37310 std::size_t r1 = vec.
size() - 1;
37316 return std::numeric_limits<T>::quiet_NaN();
37318 for (std::size_t i = r0; i <= r1; ++i)
37320 if (vec[i] == T(0))
37330 template <
typename T>
37353 const vector_t vec(parameters[0]);
37355 std::size_t r0 = 0;
37356 std::size_t r1 = vec.
size() - 1;
37362 return std::numeric_limits<T>::quiet_NaN();
37364 std::size_t cnt = 0;
37366 for (std::size_t i = r0; i <= r1; ++i)
37368 if (vec[i] != T(0)) ++cnt;
37375 template <
typename T>
37400 vector_t y(parameters[(0 == ps_index) ? 1 : 3]);
37402 std::size_t xr0 = 0;
37403 std::size_t xr1 = x.
size() - 1;
37405 std::size_t yr0 = 0;
37406 std::size_t yr1 = y.
size() - 1;
37417 const std::size_t n =
std::min(xr1 - xr0 + 1, yr1 - yr0 + 1);
37425 template <
typename T>
37452 std::size_t r0 = 0;
37453 std::size_t r1 = vec.
size() - 1;
37455 if (!
scalar_t(parameters[1]).to_uint(n))
37464 std::size_t dist = r1 - r0 + 1;
37465 std::size_t shift = n % dist;
37467 std::rotate(vec.
begin() + r0, vec.
begin() + r0 + shift, vec.
begin() + r1 + 1);
37473 template <
typename T>
37500 std::size_t r0 = 0;
37501 std::size_t r1 = vec.
size() - 1;
37503 if (!
scalar_t(parameters[1]).to_uint(n))
37512 std::size_t dist = r1 - r0 + 1;
37513 std::size_t shift = (dist - (n % dist)) % dist;
37515 std::rotate(vec.
begin() + r0, vec.
begin() + r0 + shift, vec.
begin() + r1 + 1);
37521 template <
typename T>
37548 std::size_t r0 = 0;
37549 std::size_t r1 = vec.
size() - 1;
37551 if (!
scalar_t(parameters[1]).to_uint(n))
37560 std::size_t dist = r1 - r0 + 1;
37565 std::rotate(vec.
begin() + r0, vec.
begin() + r0 + n, vec.
begin() + r1 + 1);
37567 for (std::size_t i = r1 - n + 1; i <= r1; ++i)
37576 template <
typename T>
37603 std::size_t r0 = 0;
37604 std::size_t r1 = vec.
size() - 1;
37606 if (!
scalar_t(parameters[1]).to_uint(n))
37615 std::size_t dist = r1 - r0 + 1;
37620 std::size_t shift = (dist - (n % dist)) % dist;
37622 std::rotate(vec.
begin() + r0, vec.
begin() + r0 + shift, vec.
begin() + r1 + 1);
37624 for (std::size_t i = r0; i < r0 + n; ++i)
37633 template <
typename T>
37661 std::size_t r0 = 0;
37662 std::size_t r1 = vec.
size() - 1;
37669 bool ascending =
true;
37671 if ((2 == ps_index) || (3 == ps_index))
37682 std::sort(vec.
begin() + r0, vec.
begin() + r1 + 1, std::less<T> ());
37684 std::sort(vec.
begin() + r0, vec.
begin() + r1 + 1, std::greater<T>());
37690 template <
typename T>
37717 std::size_t r0 = 0;
37718 std::size_t r1 = vec.
size() - 1;
37720 if (!
scalar_t(parameters[1]).to_uint(n))
37724 return std::numeric_limits<T>::quiet_NaN();
37726 std::nth_element(vec.
begin() + r0, vec.
begin() + r0 + n , vec.
begin() + r1 + 1);
37732 template <
typename T>
37760 T increment =
scalar_t(parameters[1])();
37761 T base = ((1 == ps_index) || (3 == ps_index)) ?
scalar_t(parameters[2])() : T(0);
37763 std::size_t r0 = 0;
37764 std::size_t r1 = vec.
size() - 1;
37767 return std::numeric_limits<T>::quiet_NaN();
37769 return std::numeric_limits<T>::quiet_NaN();
37774 for (std::size_t i = r0; i <= r1; ++i, ++j)
37776 vec[i] = base + (increment * j);
37784 template <
typename T>
37807 const vector_t vec(parameters[0]);
37809 std::size_t r0 = 0;
37810 std::size_t r1 = vec.
size() - 1;
37813 return std::numeric_limits<T>::quiet_NaN();
37818 for (std::size_t i = r0; i <= r1; ++i)
37827 template <
typename T>
37855 std::size_t r0 = 0;
37859 return std::numeric_limits<T>::quiet_NaN();
37861 return std::numeric_limits<T>::quiet_NaN();
37865 for (std::size_t i = r0; i <= r1; ++i)
37867 y[i] = (a * x[i]) + y[i];
37874 template <
typename T>
37902 std::size_t r0 = 0;
37906 return std::numeric_limits<T>::quiet_NaN();
37908 return std::numeric_limits<T>::quiet_NaN();
37910 const T a =
scalar_t(parameters[0])();
37911 const T b =
scalar_t(parameters[2])();
37913 for (std::size_t i = r0; i <= r1; ++i)
37915 y[i] = (a * x[i]) + (b * y[i]);
37922 template <
typename T>
37951 std::size_t r0 = 0;
37955 return std::numeric_limits<T>::quiet_NaN();
37957 return std::numeric_limits<T>::quiet_NaN();
37959 return std::numeric_limits<T>::quiet_NaN();
37963 for (std::size_t i = r0; i <= r1; ++i)
37965 z[i] = (a * x[i]) + y[i];
37972 template <
typename T>
38001 std::size_t r0 = 0;
38005 return std::numeric_limits<T>::quiet_NaN();
38007 return std::numeric_limits<T>::quiet_NaN();
38009 return std::numeric_limits<T>::quiet_NaN();
38011 const T a =
scalar_t(parameters[0])();
38012 const T b =
scalar_t(parameters[2])();
38014 for (std::size_t i = r0; i <= r1; ++i)
38016 z[i] = (a * x[i]) + (b * y[i]);
38023 template <
typename T>
38051 std::size_t r0 = 0;
38052 std::size_t r1 = x.
size() - 1;
38055 return std::numeric_limits<T>::quiet_NaN();
38057 return std::numeric_limits<T>::quiet_NaN();
38059 const T a =
scalar_t(parameters[0])();
38060 const T b =
scalar_t(parameters[2])();
38062 for (std::size_t i = r0; i <= r1; ++i)
38064 z[i] = (a * x[i]) + b;
38071 template <
typename T>
38098 std::size_t r0 = 0;
38102 return std::numeric_limits<T>::quiet_NaN();
38104 return std::numeric_limits<T>::quiet_NaN();
38108 for (std::size_t i = r0; i <= r1; ++i)
38110 result += (x[i] * y[i]);
38117 template <
typename T>
38144 std::size_t r0 = 0;
38148 return std::numeric_limits<T>::quiet_NaN();
38150 return std::numeric_limits<T>::quiet_NaN();
38155 for (std::size_t i = r0; i <= r1; ++i)
38164 template <
typename T>
38191 #define exprtk_register_function(FunctionName,FunctionType) \
38192 if (!symtab.add_function(FunctionName,FunctionType)) \
38195 "exprtk::rtl::vecops::register_package - Failed to add function: %s\n", \
38223 #undef exprtk_register_function
38236 namespace information
38238 static const char*
library =
"Mathematical Expression Toolkit";
38239 static const char*
version =
"2.718281828459045235360287471352662497757247093699"
38240 "95957496696762772407663035354759457138217852516642";
38245 static const std::string info_str = std::string(
library) +
38246 std::string(
" v") + std::string(
version) +
38247 std::string(
" (") +
date + std::string(
")");
38253 #ifdef exprtk_debug
38254 #undef exprtk_debug
38257 #ifdef exprtk_error_location
38258 #undef exprtk_error_location
38261 #ifdef exprtk_disable_fallthrough_begin
38262 #undef exprtk_disable_fallthrough_begin
38265 #ifdef exprtk_disable_fallthrough_end
38266 #undef exprtk_disable_fallthrough_end
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:29660
static T process(Type t1, Type t2)
Definition: exprtk.hpp:12008
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:32075
expression_node_ptr synthesize_sosr_expression(const details::operator_type &opr, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33760
virtual char_cptr base() const =0
node_type::T2 T2
Definition: exprtk.hpp:33008
Definition: exprtk.hpp:4413
generic_type::vector_view vector_t
Definition: exprtk.hpp:37931
iota()
Definition: exprtk.hpp:37745
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:29133
ff04_functor f
Definition: exprtk.hpp:16070
generic_type::vector_view vector_t
Definition: exprtk.hpp:38126
bool collect_variables(const std::string &expr_str, Sequence< std::string, Allocator > &symbol_list)
Definition: exprtk.hpp:34689
Definition: exprtk.hpp:4423
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:30758
Definition: exprtk.hpp:13130
range_t range_
Definition: exprtk.hpp:8843
generic_type::string_view string_t
Definition: exprtk.hpp:37008
static std::pair< bool, vector_t * > make(std::deque< T, Allocator > &v, const bool is_const=false)
Definition: exprtk.hpp:16324
const bfunc_t f_
Definition: exprtk.hpp:13385
bool is_stringvar(const std::string &stringvar_name) const
Definition: exprtk.hpp:18832
static std::string id()
Definition: exprtk.hpp:14195
Definition: exprtk.hpp:10014
expression_node< T >::node_type type() const
Definition: exprtk.hpp:6338
Definition: exprtk.hpp:5510
ff03_functor f
Definition: exprtk.hpp:16060
bool initialised_
Definition: exprtk.hpp:10504
str_base_ptr str_base_ptr_
Definition: exprtk.hpp:8309
static T process_2(const Sequence &arg_list)
Definition: exprtk.hpp:12678
T value() const
Definition: exprtk.hpp:6124
settings_inequality_opr
Definition: exprtk.hpp:19302
settings_store & disable_inequality_operation(settings_inequality_opr inequality)
Definition: exprtk.hpp:19606
Definition: exprtk.hpp:2862
static std::string id()
Definition: exprtk.hpp:14278
expression_node< T >::node_type type() const
Definition: exprtk.hpp:5449
std::string assign_opr_to_string(details::operator_type opr)
Definition: exprtk.hpp:19746
bool token_is(const token_t::token_type &ttype, const token_advance_mode mode=e_advance)
Definition: exprtk.hpp:4016
opr_base< T >::Type Type
Definition: exprtk.hpp:12082
Definition: exprtk.hpp:4436
Definition: exprtk.hpp:35779
expression_node_ptr synthesize_null_expression(const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:34188
details::node_allocator node_allocator_
Definition: exprtk.hpp:34654
vovocov_t::sf4_type sf4_type
Definition: exprtk.hpp:31749
scoped_deq_delete(parser< T > &pr, std::deque< ptr_t > &deq)
Definition: exprtk.hpp:20752
static T_ execute(ifunction &f, T_(&v)[9])
Definition: exprtk.hpp:11239
bool compute(const std::string &expression_string, T &result)
Definition: exprtk.hpp:35041
void clear_functions()
Definition: exprtk.hpp:16745
bool update_error(type &error, const std::string &expression)
Definition: exprtk.hpp:18037
bipowninv_node< T, PowOp > & operator=(const bipowninv_node< T, PowOp > &)
expression_ptr condition_
Definition: exprtk.hpp:6411
bool var_range()
Definition: exprtk.hpp:6882
bool invalid_state_
Definition: exprtk.hpp:23316
std::string name
Definition: exprtk.hpp:18297
operator_type operation() const
Definition: exprtk.hpp:14738
static expression_node< T >::node_type type()
Definition: exprtk.hpp:12151
const vds_t & vds() const
Definition: exprtk.hpp:10957
expression_node< T >::node_type type() const
Definition: exprtk.hpp:8058
Definition: exprtk.hpp:4909
covoc_t::type1 node_type
Definition: exprtk.hpp:30011
std::string type_id() const
Definition: exprtk.hpp:14089
void register_symbol_table(symbol_table< T > &st)
Definition: exprtk.hpp:17777
vector_holder_t & vec_holder()
Definition: exprtk.hpp:7174
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:37657
Definition: exprtk.hpp:4917
node_type & operator=(node_type &)
Definition: exprtk.hpp:14110
T0 t0_
Definition: exprtk.hpp:13751
static T process(const T &t0, const T &t1, const T &t2, const T &t3, const bfunc_t bf0, const bfunc_t bf1, const bfunc_t bf2)
Definition: exprtk.hpp:13532
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:32655
const std::size_t param_seq_index_
Definition: exprtk.hpp:11775
Definition: exprtk.hpp:9384
bool is_operator_char(const char_t c)
Definition: exprtk.hpp:101
T compute_pow10(T d, const int exponent)
Definition: exprtk.hpp:1618
expression_node< typename node_type::value_type > * allocate_type(T1 t1, T2 t2, T3 t3, T4 t4) const
Definition: exprtk.hpp:15644
Definition: exprtk.hpp:32196
void dump_error(const type &error)
Definition: exprtk.hpp:18079
generic_type::scalar_view scalar_t
Definition: exprtk.hpp:37584
expression(const symbol_table< T > &symbol_table)
Definition: exprtk.hpp:17700
Definition: exprtk.hpp:1362
Definition: exprtk.hpp:2028
vector_interface< T > * ivector_ptr
Definition: exprtk.hpp:13072
bool is_unary_node(const expression_node< T > *node)
Definition: exprtk.hpp:4997
ivararg_function< T > ivararg_function_t
Definition: exprtk.hpp:18127
node_type::T3 T3
Definition: exprtk.hpp:33235
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:37712
Definition: exprtk.hpp:14043
static std::size_t min_size(control_block *cb0, control_block *cb1)
Definition: exprtk.hpp:4731
virtual bool join(const token &, const token &, const token &, token &)
Definition: exprtk.hpp:3096
Definition: exprtk.hpp:4399
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:29600
int v
Definition: obj.cpp:19
details::T0oT1oT2oT3_define< T, const_t, cref_t, const_t, cref_t > covocov_t
Definition: exprtk.hpp:18216
std::string & s0()
Definition: exprtk.hpp:15105
Definition: exprtk.hpp:4433
Definition: exprtk.hpp:17970
T0 t0() const
Definition: exprtk.hpp:14253
expression_node_ptr const_optimise_sf4(const details::operator_type &operation, expression_node_ptr(&branch)[4])
Definition: exprtk.hpp:26939
complex_type_tag()
Definition: exprtk.hpp:754
static expression_node< T >::node_type type()
Definition: exprtk.hpp:12199
virtual ~sosos_base_node()
Definition: exprtk.hpp:13244
const vds_t & vds() const
Definition: exprtk.hpp:10306
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:30674
bool disable_zero_return_
Definition: exprtk.hpp:19801
SType2 s2_
Definition: exprtk.hpp:15124
expression_node< T >::node_type type() const
Definition: exprtk.hpp:5860
expression_node_ptr conditional_string(expression_node_ptr condition, expression_node_ptr consequent, expression_node_ptr alternative) const
Definition: exprtk.hpp:26353
vector_node_ptr vec()
Definition: exprtk.hpp:10473
static T result(T v)
Definition: exprtk.hpp:1556
static bool compile_right(expression_generator< Type > &expr_gen, ExternalType t, const details::operator_type &operation, expression_node_ptr &sf3node, expression_node_ptr &result)
Definition: exprtk.hpp:29286
type_store< T > generic_type
Definition: exprtk.hpp:15959
std::stack< std::pair< char, std::size_t > > stack_
Definition: exprtk.hpp:3486
expression_node< T > * expression_ptr
Definition: exprtk.hpp:14719
T value() const
Definition: exprtk.hpp:13871
Definition: exprtk.hpp:4456
Definition: exprtk.hpp:9430
bool operator()(const lexer::token &t)
Definition: exprtk.hpp:3512
generic_type::scalar_view scalar_t
Definition: exprtk.hpp:37009
static T_ execute(ifunction &f, T_(&v)[12])
Definition: exprtk.hpp:11218
bool is_continue_node(const expression_node< T > *node)
Definition: exprtk.hpp:5099
control_block(expression_ptr e)
Definition: exprtk.hpp:17607
vector_interface< T > * ivector_ptr
Definition: exprtk.hpp:12833
std::string substr(const std::size_t &begin, const std::size_t &end)
Definition: exprtk.hpp:2313
sf3_var_node(const T &v0, const T &v1, const T &v2)
Definition: exprtk.hpp:9262
opr_base< T >::Type Type
Definition: exprtk.hpp:11982
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:28894
bool is_end(details::char_cptr itr)
Definition: exprtk.hpp:2333
Definition: exprtk.hpp:12174
set_t invalid_comb_
Definition: exprtk.hpp:3787
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:31811
axpby()
Definition: exprtk.hpp:37887
node_type::T3 T3
Definition: exprtk.hpp:32485
static std::string id()
Definition: exprtk.hpp:13821
Definition: exprtk.hpp:2024
static T result(T v)
Definition: exprtk.hpp:1554
std::size_t ip_index
Definition: exprtk.hpp:18302
expression_node_ptr synthesize_csrocsr_expression(const details::operator_type &opr, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33953
Definition: exprtk.hpp:2027
igfun_t::generic_type generic_type
Definition: exprtk.hpp:37291
static expression_node< T >::node_type type()
Definition: exprtk.hpp:12142
const range_t & range_ref() const
Definition: exprtk.hpp:8962
T value() const
Definition: exprtk.hpp:11377
Definition: exprtk.hpp:4929
std::vector< unsigned char > delete_branch_
Definition: exprtk.hpp:9380
bool wc_imatch(const std::string &wild_card, const std::string &str)
Definition: exprtk.hpp:643
expression_node_t * expression_node_ptr
Definition: exprtk.hpp:18317
stringvar_node()
Definition: exprtk.hpp:7492
range_t rp_
Definition: exprtk.hpp:5644
static T process_1(const Sequence &arg_list)
Definition: exprtk.hpp:12671
operator_type operation_
Definition: exprtk.hpp:5936
static void assign(RefType t1, Type t2)
Definition: exprtk.hpp:12010
std::set< std::string, details::ilesscompare > ignore_set_
Definition: exprtk.hpp:3229
vec_data_store(const std::size_t &size)
Definition: exprtk.hpp:4638
expression_node_ptr parse_define_string_statement(const std::string &str_name, expression_node_ptr initialisation_expression)
Definition: exprtk.hpp:24076
expression_node< T >::node_type type() const
Definition: exprtk.hpp:13962
expression_node_ptr synthesize_csrosr_expression(const details::operator_type &opr, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33924
const T c_
Definition: exprtk.hpp:14483
virtual void init()
Definition: exprtk.hpp:2855
#define register_unary_op(Op, UnaryFunctor)
vovoc_t::sf3_type sf3_type
Definition: exprtk.hpp:29537
static T result(T v)
Definition: exprtk.hpp:1558
int remainder
Definition: exprtk.hpp:4520
Definition: exprtk.hpp:4412
details::assignment_rebasevec_elem_node< T > assignment_rebasevec_elem_node_t
Definition: exprtk.hpp:18166
token_t eof_token_
Definition: exprtk.hpp:2840
settings_store & disable_logic_operation(settings_logic_opr logic)
Definition: exprtk.hpp:19567
expression_node< T > * expression_ptr
Definition: exprtk.hpp:9638
node_type::T1 T1
Definition: exprtk.hpp:32483
symbol_table_t::function_ptr function_ptr
Definition: exprtk.hpp:18551
vds_t & vds()
Definition: exprtk.hpp:9883
std::string & s1()
Definition: exprtk.hpp:14810
void parse_hex(Iterator &itr, Iterator end, std::string::value_type &result)
Definition: exprtk.hpp:311
bool rsrvd_sym_usr_disabled() const
Definition: exprtk.hpp:19436
parser_t * parser_
Definition: exprtk.hpp:34368
T equal_impl(const T v0, const T v1, int_type_tag)
Definition: exprtk.hpp:886
char_cptr base() const
Definition: exprtk.hpp:8038
double time() const
Definition: exprtk.hpp:36413
const range_t & range_ref() const
Definition: exprtk.hpp:8053
const std::size_t stride_
Definition: exprtk.hpp:3152
ptr_t * p_
Definition: exprtk.hpp:20740
opr_base< T >::Type Type
Definition: exprtk.hpp:12365
expression_node_ptr parse_define_vector_statement(const std::string &vec_name)
Definition: exprtk.hpp:23752
std::pair< lexer::token::token_type, lexer::token::token_type > token_pair_t
Definition: exprtk.hpp:3624
axpbz< T > b1_axpbz
Definition: exprtk.hpp:38185
bool const_range()
Definition: exprtk.hpp:6876
operator_type operation_
Definition: exprtk.hpp:5830
Definition: exprtk.hpp:5243
scoped_bool_negator(bool &bb)
Definition: exprtk.hpp:20815
results_context_t * results_context_
Definition: exprtk.hpp:34661
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:37833
bool numeric_check_enabled() const
Definition: exprtk.hpp:19428
operator_type operation() const
Definition: exprtk.hpp:14800
node_type::T1 T1
Definition: exprtk.hpp:33064
Definition: exprtk.hpp:37733
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:30572
details::T0oT1oT2_sf3< T, T0, T1, T2 > sf3_type
Definition: exprtk.hpp:14331
Definition: exprtk.hpp:31858
Definition: exprtk.hpp:32591
range_data_type< T > range_data_type_t
Definition: exprtk.hpp:11420
Definition: exprtk.hpp:8851
vector_interface< T > * ivector_ptr
Definition: exprtk.hpp:13035
function_compositor()
Definition: exprtk.hpp:35898
static expression_node_ptr process(expression_generator< Type > &, const details::operator_type &, expression_node_ptr(&)[2])
Definition: exprtk.hpp:33568
Definition: exprtk.hpp:4437
generic_type::vector_view vector_t
Definition: exprtk.hpp:37642
T process(const operator_type operation, const T arg)
Definition: exprtk.hpp:4880
Definition: exprtk.hpp:4442
Definition: exprtk.hpp:4925
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:31252
T value() const
Definition: exprtk.hpp:9995
node_type::T3 T3
Definition: exprtk.hpp:33178
expression_node< T >::node_type type() const
Definition: exprtk.hpp:15254
settings_store settings_t
Definition: exprtk.hpp:19813
static T process(const std::string &t1, const std::string &t2)
Definition: exprtk.hpp:12054
function & name(const std::string &n)
Definition: exprtk.hpp:35468
expression_node_ptr synthesize_expression(F *f, expression_node_ptr(&branch)[N])
Definition: exprtk.hpp:34322
bool is_string_function_node(const expression_node< T > *node)
Definition: exprtk.hpp:15352
Definition: exprtk.hpp:9230
std::vector< expression_node_ptr > arg_list_t
Definition: exprtk.hpp:26603
value_ptr value_at(const std::size_t &index) const
Definition: exprtk.hpp:5296
igfun_t::generic_type generic_type
Definition: exprtk.hpp:37834
Definition: exprtk.hpp:4426
node_type::T2 T2
Definition: exprtk.hpp:30755
vocovov_t::sf4_type sf4_type
Definition: exprtk.hpp:32780
expression_node< T >::node_type type() const
Definition: exprtk.hpp:11718
void clear()
Definition: exprtk.hpp:2039
data_t data
Definition: exprtk.hpp:4615
T0oT1(T0oT1< T, T0, T1 > &)
Definition: exprtk.hpp:13748
Definition: exprtk.hpp:4451
T floor_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1293
expression_node< T >::node_type type() const
Definition: exprtk.hpp:14795
static T process_5(const Sequence &arg_list)
Definition: exprtk.hpp:12480
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:31924
Definition: exprtk.hpp:4004
expression_node< T > * expression_ptr
Definition: exprtk.hpp:15235
std::string * value_
Definition: exprtk.hpp:7560
expression_node< T > * expression_ptr
Definition: exprtk.hpp:9234
Definition: exprtk.hpp:4426
iota< T > ia
Definition: exprtk.hpp:38179
type_store_t & operator[](const std::size_t &index)
Definition: exprtk.hpp:4354
static const std::string assignment_ops_list[]
Definition: exprtk.hpp:483
static T process(Type t1, Type t2, Type t3)
Definition: exprtk.hpp:11997
void stop()
Definition: exprtk.hpp:36391
void scan_string()
Definition: exprtk.hpp:2735
node_type::T2 T2
Definition: exprtk.hpp:31864
Definition: exprtk.hpp:4421
expression_node_ptr parse_return_statement()
Definition: exprtk.hpp:24663
Definition: exprtk.hpp:2029
vovovov_t::sf4_type sf4_type
Definition: exprtk.hpp:32611
expression_node< T >::node_type type() const
Definition: exprtk.hpp:9468
ipowinv_node< T, PowOp > & operator=(const ipowinv_node< T, PowOp > &)
bool initialised_
Definition: exprtk.hpp:9897
return_envelope_node(expression_ptr body, results_context_t &rc)
Definition: exprtk.hpp:11852
static T process_3(const Sequence &arg_list)
Definition: exprtk.hpp:12273
virtual const std::string & ref() const
Definition: exprtk.hpp:7623
covoc_t::sf3_type sf3_type
Definition: exprtk.hpp:29898
expression_ptr index_
Definition: exprtk.hpp:7181
bool close()
Definition: exprtk.hpp:36674
read()
Definition: exprtk.hpp:36957
vocovoc_t::type1 node_type
Definition: exprtk.hpp:31974
covovoc_t::sf4_type sf4_type
Definition: exprtk.hpp:33005
Definition: exprtk.hpp:4919
struct timeval start_time_
Definition: exprtk.hpp:36434
Definition: exprtk.hpp:4397
T value() const
Definition: exprtk.hpp:13786
void add_auxiliary_symtab(symbol_table_t &symtab)
Definition: exprtk.hpp:35921
expression_node_ptr parse_corpus()
Definition: exprtk.hpp:20292
Definition: exprtk.hpp:4409
Definition: exprtk.hpp:32084
static expression_node< T >::node_type type()
Definition: exprtk.hpp:12011
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:37738
lexer::helper::numeric_checker numeric_checker_
Definition: exprtk.hpp:34680
token_list_itr_t store_token_itr_
Definition: exprtk.hpp:2839
T1 t1_
Definition: exprtk.hpp:14113
const T & v2_
Definition: exprtk.hpp:9319
expression_node_ptr synthesize_unary_expression(const details::operator_type &operation, expression_node_ptr(&branch)[1])
Definition: exprtk.hpp:26821
exprtk::vector_view< Type > vector_view_t
Definition: exprtk.hpp:5352
expression_node_ptr synthesize_srocs_expression(const details::operator_type &opr, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33836
Definition: exprtk.hpp:4930
generic_type::scalar_view scalar_t
Definition: exprtk.hpp:37481
Definition: exprtk.hpp:4932
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:37995
details::string_concat_node< T > string_concat_node_t
Definition: exprtk.hpp:18158
vec_data_store< T > vds_t
Definition: exprtk.hpp:10058
vococov_t::type1 node_type
Definition: exprtk.hpp:32086
~str_xrox_node()
Definition: exprtk.hpp:14779
T value() const
Definition: exprtk.hpp:11867
vector_holder_t & vec_holder()
Definition: exprtk.hpp:7113
expression_node< T > * expression_ptr
Definition: exprtk.hpp:5890
T sec_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1305
static T process(const ivector_ptr v)
Definition: exprtk.hpp:13050
Definition: exprtk.hpp:33565
T value() const
Definition: exprtk.hpp:6067
functor_t::qfunc_t qfunc_t
Definition: exprtk.hpp:14137
range_interface< T > irange_t
Definition: exprtk.hpp:7998
generic_type::vector_view vector_t
Definition: exprtk.hpp:37434
bool is_sign(const char_t c)
Definition: exprtk.hpp:147
expression_node< typename node_type::value_type > * allocate_rrrr(T1 &t1, T2 &t2, T3 &t3, T4 &t4) const
Definition: exprtk.hpp:15531
Definition: exprtk.hpp:573
expression_node< T > * expression_ptr
Definition: exprtk.hpp:9561
open()
Definition: exprtk.hpp:36824
bool remove_vararg_function(const std::string &vararg_function_name)
Definition: exprtk.hpp:17209
const T & v_
Definition: exprtk.hpp:13312
Definition: exprtk.hpp:4447
Definition: exprtk.hpp:12165
Definition: exprtk.hpp:4923
Definition: exprtk.hpp:37691
bool sf4_optimisable(const std::string &sf4id, quaternary_functor_t &qfunc)
Definition: exprtk.hpp:25659
Definition: exprtk.hpp:4445
Definition: exprtk.hpp:4419
node_type::T1 T1
Definition: exprtk.hpp:31807
range_t & range_ref()
Definition: exprtk.hpp:8549
expression_node_ptr varnode_optimise_varargfunc(const details::operator_type &operation, Sequence< expression_node_ptr, Allocator > &arg_list)
Definition: exprtk.hpp:27088
opr_base< T >::Type Type
Definition: exprtk.hpp:12149
static void assign(RefType t1, Type t2)
Definition: exprtk.hpp:11998
irange_t * irange_ptr
Definition: exprtk.hpp:7732
bool is_string_condition_node(const expression_node< T > *node)
Definition: exprtk.hpp:15358
const T c_
Definition: exprtk.hpp:14709
Definition: exprtk.hpp:7482
Definition: exprtk.hpp:2028
T value() const
Definition: exprtk.hpp:11069
close()
Definition: exprtk.hpp:36869
vococov_t::type3 node_type
Definition: exprtk.hpp:33061
T d2g_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1309
T0oT1oT2oT3_sf4ext(node_type &)
Definition: exprtk.hpp:14293
node_type::T1 T1
Definition: exprtk.hpp:32726
void reset()
Definition: exprtk.hpp:18965
const bfunc_t f1_
Definition: exprtk.hpp:13941
settings_store & disable_all_logic_ops()
Definition: exprtk.hpp:19383
vec_data_store< T > vds_t
Definition: exprtk.hpp:9757
vovovoc_t::type1 node_type
Definition: exprtk.hpp:31692
swap_vecvec_node(expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:7382
Definition: exprtk.hpp:4411
virtual ~token_scanner()
Definition: exprtk.hpp:2866
Definition: exprtk.hpp:26662
vector_node_ptr temp_vec_node_
Definition: exprtk.hpp:10659
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:37790
static T result(T v)
Definition: exprtk.hpp:1533
Definition: exprtk.hpp:19265
expression_node< typename node_type::value_type > * allocate_cr(const T1 &t1, T2 &t2) const
Definition: exprtk.hpp:15482
ProcessMode process_mode_t
Definition: exprtk.hpp:13765
Definition: exprtk.hpp:26601
generator generator_t
Definition: exprtk.hpp:3954
Definition: exprtk.hpp:28892
void set_synthesis_error(const std::string &synthesis_error_message)
Definition: exprtk.hpp:34384
Definition: exprtk.hpp:4407
bool is_ivector_node(const expression_node< T > *node)
Definition: exprtk.hpp:5057
std::size_t size() const
Definition: exprtk.hpp:10147
T & v_
Definition: exprtk.hpp:4317
const T & v1_
Definition: exprtk.hpp:9284
Definition: exprtk.hpp:12090
covocov_t::sf4_type sf4_type
Definition: exprtk.hpp:32892
std::size_t line_no
Definition: exprtk.hpp:17991
vocovov_t::sf4_type sf4_type
Definition: exprtk.hpp:31805
generic_type::scalar_view scalar_t
Definition: exprtk.hpp:37740
dependent_entity_collector(const std::size_t options=e_ct_none)
Definition: exprtk.hpp:19073
settings_store(const std::size_t compile_options=compile_all_opts)
Definition: exprtk.hpp:19318
T0oT1(T0 p0, T1 p1, const bfunc_t p2)
Definition: exprtk.hpp:13699
T cosh_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1291
vararg_function_node(VarArgFunction *func, const std::vector< expression_ptr > &arg_list)
Definition: exprtk.hpp:11353
std::map< operator_t, trinary_functor_t > trinary_op_map_t
Definition: exprtk.hpp:18189
void set_max_num_args(FunctionType &func, const std::size_t &num_args)
Definition: exprtk.hpp:15832
Definition: exprtk.hpp:4394
Definition: exprtk.hpp:32664
Definition: exprtk.hpp:12932
Definition: exprtk.hpp:4932
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:28278
virtual const T & v1() const =0
expression_node< T >::node_type type() const
Definition: exprtk.hpp:9372
const range_t & range_ref() const
Definition: exprtk.hpp:7701
bool initialised_
Definition: exprtk.hpp:8566
static const double pi
Definition: exprtk.hpp:739
covoc_t::sf3_type sf3_type
Definition: exprtk.hpp:30012
expression_ptr test_
Definition: exprtk.hpp:8846
Definition: exprtk.hpp:1362
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:33162
Definition: exprtk.hpp:4452
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:30488
Definition: exprtk.hpp:4912
stringvar_node_t * stringvar_node_ptr
Definition: exprtk.hpp:18241
operator_type operation() const
Definition: exprtk.hpp:14155
T * data_ptr_t
Definition: exprtk.hpp:4068
Definition: exprtk.hpp:4419
Definition: exprtk.hpp:4429
token_type
Definition: exprtk.hpp:2015
func_1param()
Definition: exprtk.hpp:35741
T2 t2() const
Definition: exprtk.hpp:14263
Definition: exprtk.hpp:4915
vovov_t::sf3_type sf3_type
Definition: exprtk.hpp:29417
std::string get_vector_name(const vector_holder_ptr &ptr) const
Definition: exprtk.hpp:18924
expression_node< typename node_type::value_type > * allocate(const T1 &t1, const T2 &t2) const
Definition: exprtk.hpp:15475
expression_ptr alternative_
Definition: exprtk.hpp:8730
void skip_comments()
Definition: exprtk.hpp:2363
range_pack()
Definition: exprtk.hpp:6830
bool is_binary_node(const expression_node< T > *node)
Definition: exprtk.hpp:5009
node_type::T3 T3
Definition: exprtk.hpp:32952
std::size_t size
Definition: exprtk.hpp:4614
expression_node< typename node_type::value_type > * allocate() const
Definition: exprtk.hpp:15447
expression_node_ptr for_loop(expression_node_ptr &initialiser, expression_node_ptr &condition, expression_node_ptr &incrementor, expression_node_ptr &loop_body, bool brkcont=false) const
Definition: exprtk.hpp:26475
real_type_tag()
Definition: exprtk.hpp:753
ff08_functor f
Definition: exprtk.hpp:16112
static T process_3(const Sequence &arg_list)
Definition: exprtk.hpp:12466
std::string type_id() const
Definition: exprtk.hpp:13998
T3 t3_
Definition: exprtk.hpp:14299
void load_from(const symbol_table< T > &st)
Definition: exprtk.hpp:17419
bool invalid() const
Definition: exprtk.hpp:23216
expression_node< T > * expression_ptr
Definition: exprtk.hpp:7316
Definition: exprtk.hpp:36596
node_type::T0 T0
Definition: exprtk.hpp:33119
T min_impl(const T v0, const T v1, real_type_tag)
Definition: exprtk.hpp:861
expression_node_ptr parse_symtab_symbol()
Definition: exprtk.hpp:24861
std::string diagnostic
Definition: exprtk.hpp:17988
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:37495
const bool loop_body_deletable_
Definition: exprtk.hpp:6352
expression_node< T >::node_type type() const
Definition: exprtk.hpp:14733
Type * ptr_t
Definition: exprtk.hpp:20713
Definition: exprtk.hpp:14492
node_type::T2 T2
Definition: exprtk.hpp:31921
settings_compilation_options
Definition: exprtk.hpp:19231
Definition: exprtk.hpp:10995
void process_lexer_errors()
Definition: exprtk.hpp:20023
expression_node< typename node_type::value_type > * allocate_rrrrr(T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5) const
Definition: exprtk.hpp:15538
opr_base< T >::Type Type
Definition: exprtk.hpp:12062
vector_node_ptr vec() const
Definition: exprtk.hpp:10281
std::string function_name_
Definition: exprtk.hpp:23318
Definition: exprtk.hpp:15164
T nor_impl(const T v0, const T v1, real_type_tag)
Definition: exprtk.hpp:1136
Definition: exprtk.hpp:4411
control_block(const std::size_t &dsize, data_t dptr, bool dstrct=false)
Definition: exprtk.hpp:4567
ipow_node(const T &v)
Definition: exprtk.hpp:15141
static T process(const T &, const T &)
Definition: exprtk.hpp:12187
parser_t & parser_
Definition: exprtk.hpp:18502
Definition: exprtk.hpp:17577
expression_ptr condition_
Definition: exprtk.hpp:6576
covovoc_t::type3 node_type
Definition: exprtk.hpp:33004
node_type::T1 T1
Definition: exprtk.hpp:32426
Definition: exprtk.hpp:11686
T asin_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1285
expression_node_ptr parse_multi_sequence(const std::string &source="")
Definition: exprtk.hpp:22520
Definition: exprtk.hpp:18111
void release()
Definition: exprtk.hpp:5692
T0 t0() const
Definition: exprtk.hpp:14165
Definition: exprtk.hpp:4927
~string_size_node()
Definition: exprtk.hpp:8279
T0oT1oT2_sf3ext(T0 p0, T1 p1, T2 p2)
Definition: exprtk.hpp:14052
details::T0oT1oT2_define< T, const_t, cref_t, cref_t > covov_t
Definition: exprtk.hpp:18205
bool is_generally_string_node(const expression_node< T > *node)
Definition: exprtk.hpp:15382
control_block(st_data *data)
Definition: exprtk.hpp:16661
std::pair< bool, type_ptr > type_pair_t
Definition: exprtk.hpp:16211
Definition: exprtk.hpp:5545
Definition: exprtk.hpp:2024
covovov_t::type4 node_type
Definition: exprtk.hpp:33341
T modulus_impl(const T v0, const T v1, int_type_tag)
Definition: exprtk.hpp:935
Definition: exprtk.hpp:10819
static std::string result()
Definition: exprtk.hpp:13455
opr_base< T >::Type Type
Definition: exprtk.hpp:12112
results_context< T > results_context_t
Definition: exprtk.hpp:11850
Definition: exprtk.hpp:18957
Definition: exprtk.hpp:4903
void clear_variables(const bool delete_node=true)
Definition: exprtk.hpp:16740
generic_type::scalar_view scalar_t
Definition: exprtk.hpp:38031
expression_node_ptr parse_break_statement()
Definition: exprtk.hpp:23663
std::size_t size() const
Definition: exprtk.hpp:10640
Definition: exprtk.hpp:4402
lexer::helper::operator_joiner operator_joiner_3_
Definition: exprtk.hpp:34677
static T process(const Sequence< Type, Allocator > &arg_list)
Definition: exprtk.hpp:12648
node_type::T1 T1
Definition: exprtk.hpp:32257
sos_node(SType0 p0, SType1 p1)
Definition: exprtk.hpp:14723
Definition: exprtk.hpp:4907
bool inequality_enabled(const details::operator_type &inequality)
Definition: exprtk.hpp:19481
Definition: exprtk.hpp:4406
const value_t & operator[](const std::size_t &i) const
Definition: exprtk.hpp:4245
bool is_control_struct(const std::string &cntrl_strct)
Definition: exprtk.hpp:539
static T evaluate(const Type x, const Type c6, const Type c5, const Type c4, const Type c3, const Type c2, const Type c1, const Type c0)
Definition: exprtk.hpp:35235
Definition: exprtk.hpp:7373
void register_return_results(expression< T > &e)
Definition: exprtk.hpp:34451
expression_node< T > * expression_ptr
Definition: exprtk.hpp:6361
details::assignment_vec_node< T > assignment_vec_node_t
Definition: exprtk.hpp:18168
Definition: exprtk.hpp:33228
std::string & s1()
Definition: exprtk.hpp:14948
irange_t * irange_ptr
Definition: exprtk.hpp:7860
operator_type operation() const
Definition: exprtk.hpp:14567
Definition: exprtk.hpp:2020
Definition: exprtk.hpp:4907
uvouv_node< T > & operator=(uvouv_node< T > &)
Definition: exprtk.hpp:4422
expression_node< T > * expression_ptr
Definition: exprtk.hpp:7005
const std::size_t size_
Definition: exprtk.hpp:4122
bool strength_reduction_enabled() const
Definition: exprtk.hpp:25559
Type * ptr_t
Definition: exprtk.hpp:20783
generic_function_ptr get_string_function(const std::string &function_name) const
Definition: exprtk.hpp:18724
expression_node_ptr synthesize_socsr_expression(const details::operator_type &opr, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33773
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:38093
range_interface< T > irange_t
Definition: exprtk.hpp:8861
lexer::helper::helper_assembly helper_assembly_
Definition: exprtk.hpp:34673
void reset()
Definition: exprtk.hpp:20397
irange_t * irange_ptr
Definition: exprtk.hpp:14976
Definition: exprtk.hpp:13757
type & operator=(const type &vds)
Definition: exprtk.hpp:4657
opr_base< T >::Type Type
Definition: exprtk.hpp:12723
token token_t
Definition: exprtk.hpp:2189
~generic_string_range_node()
Definition: exprtk.hpp:7763
Definition: exprtk.hpp:2017
results_context_t & results_ctx()
Definition: exprtk.hpp:34624
branch_t branch_[4]
Definition: exprtk.hpp:5976
node_type::T2 T2
Definition: exprtk.hpp:30839
settings_store & enable_local_vardef()
Definition: exprtk.hpp:19359
std::size_t parameter_count_
Definition: exprtk.hpp:11307
static details::operator_type operation()
Definition: exprtk.hpp:12125
Definition: exprtk.hpp:4423
virtual ~cob_base_node()
Definition: exprtk.hpp:13174
bov_node< T, Operation > & operator=(const bov_node< T, Operation > &)
expression_node< T >::node_type type() const
Definition: exprtk.hpp:6752
vararg_function_ptr get_vararg_function(const std::string &vararg_function_name) const
Definition: exprtk.hpp:16852
Definition: exprtk.hpp:4442
Definition: exprtk.hpp:4439
variable_node(T &v)
Definition: exprtk.hpp:6787
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:32786
bool valid_operator(const details::operator_type &operation, unary_functor_t &uop)
Definition: exprtk.hpp:25576
const bool loop_body_deletable_
Definition: exprtk.hpp:6414
~vector_elem_node()
Definition: exprtk.hpp:7085
symbol_table_t symbol_table_
Definition: exprtk.hpp:36126
vector_view(const vector_view< T > &vv)
Definition: exprtk.hpp:4076
stringvar_ptr get_stringvar(const std::string &string_name) const
Definition: exprtk.hpp:16831
~str_xoxr_node()
Definition: exprtk.hpp:14842
vector_node< T > * vector_node_ptr
Definition: exprtk.hpp:9756
opr_base< T >::Type Type
Definition: exprtk.hpp:12176
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:37213
Definition: exprtk.hpp:4423
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:31270
expression_ptr body_
Definition: exprtk.hpp:11897
Definition: exprtk.hpp:35807
node_type::T2 T2
Definition: exprtk.hpp:30587
Definition: exprtk.hpp:16296
node_type & operator=(node_type &)
Definition: exprtk.hpp:13837
bipow_node(expression_ptr brnch)
Definition: exprtk.hpp:15172
T value() const
Definition: exprtk.hpp:14410
T3 t3() const
Definition: exprtk.hpp:14268
vds_t vds_
Definition: exprtk.hpp:10967
expression_node< T >::node_type type() const
Definition: exprtk.hpp:6255
T acos_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1283
std::string & s0()
Definition: exprtk.hpp:14805
expression_node< T > * expression_ptr
Definition: exprtk.hpp:10018
expression_node< T > * expression_ptr
Definition: exprtk.hpp:5784
bool is_vector_node(const expression_node< T > *node)
Definition: exprtk.hpp:5051
static expression_node< T >::node_type type()
Definition: exprtk.hpp:12179
static T result(T v)
Definition: exprtk.hpp:1563
T value() const
Definition: exprtk.hpp:7324
std::vector< token_t >::iterator token_list_itr_t
Definition: exprtk.hpp:2191
Definition: exprtk.hpp:2185
string_base_node< T > * str_base_ptr
Definition: exprtk.hpp:8333
node_type::T2 T2
Definition: exprtk.hpp:32614
string_base_node< T > * str_base_ptr
Definition: exprtk.hpp:14972
range_ptr str1_range_ptr_
Definition: exprtk.hpp:8220
parser_t parser_
Definition: exprtk.hpp:36127
bool add_infinity()
Definition: exprtk.hpp:17245
uchar_t buffer[64]
Definition: exprtk.hpp:5436
expression_node_ptr synthesize_swap_expression(expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:27895
generic_type::vector_view vector_t
Definition: exprtk.hpp:37585
Operation operation_t
Definition: exprtk.hpp:14498
std::string expression_
Definition: exprtk.hpp:35487
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t t(t+t)") define_sfop3(16
bool is_sf4ext_node(const expression_node< T > *n)
Definition: exprtk.hpp:14303
vector_node_ptr vec() const
Definition: exprtk.hpp:10932
bool is_genricstring_range_node(const expression_node< T > *node)
Definition: exprtk.hpp:15376
all_false< T > af
Definition: exprtk.hpp:38168
vec_data_store< T > vds_t
Definition: exprtk.hpp:7380
Definition: exprtk.hpp:16417
swap_genstrings_node(expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:8082
~while_loop_bc_node()
Definition: exprtk.hpp:6370
Definition: exprtk.hpp:4913
expression_node< typename node_type::value_type > * allocate_tttt(T1 t1, T2 t2, T3 t3, T4 t4) const
Definition: exprtk.hpp:15517
static details::operator_type operation()
Definition: exprtk.hpp:12106
std::size_t process_stride_3(generator &g)
Definition: exprtk.hpp:3126
Definition: exprtk.hpp:18109
igfun_t::generic_type generic_type
Definition: exprtk.hpp:37153
Definition: exprtk.hpp:4404
Definition: exprtk.hpp:4434
Definition: exprtk.hpp:1531
settings_store & disable_all_inequality_ops()
Definition: exprtk.hpp:19410
bool function_disabled(const std::string &function_name)
Definition: exprtk.hpp:19490
static T process_7(const Sequence &arg_list)
Definition: exprtk.hpp:12805
void assign(const parameter_list_t &pl)
Definition: exprtk.hpp:4374
type_store & front()
Definition: exprtk.hpp:4192
char char_t
Definition: exprtk.hpp:87
details::assignment_node< T > assignment_node_t
Definition: exprtk.hpp:18164
ff12_functor f
Definition: exprtk.hpp:16157
vector_node< T > * vector_node_ptr
Definition: exprtk.hpp:10825
bool enable_collect_vars_
Definition: exprtk.hpp:19796
Definition: exprtk.hpp:36556
static T result(T v)
Definition: exprtk.hpp:1555
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:31793
SType0 s0_
Definition: exprtk.hpp:14817
symtab_store symtab_store_
Definition: exprtk.hpp:34655
char_cptr base() const
Definition: exprtk.hpp:8539
Definition: exprtk.hpp:4409
std::pair< expression_ptr, bool > branch_t
Definition: exprtk.hpp:11025
bool add(const std::string &symbol_name, exprtk::vector_view< T > &v, const bool is_const=false)
Definition: exprtk.hpp:16350
Definition: exprtk.hpp:11779
std::size_t size() const
Definition: exprtk.hpp:2237
Definition: exprtk.hpp:4445
static details::operator_type operation()
Definition: exprtk.hpp:12000
Definition: exprtk.hpp:9557
Definition: exprtk.hpp:4920
static bool is_unary(const expression< T > &expr)
Definition: exprtk.hpp:17938
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1)
Definition: exprtk.hpp:29588
void scan_token()
Definition: exprtk.hpp:2440
std::vector< expression_ptr > arg_list_
Definition: exprtk.hpp:11404
static T process(const arg_list_t &arg)
Definition: exprtk.hpp:26664
std::pair< expression_ptr, bool > branch_t
Definition: exprtk.hpp:11422
Operation operation_t
Definition: exprtk.hpp:14402
bool is_rebasevector_celem_node(const expression_node< T > *node)
Definition: exprtk.hpp:5045
details::vector_elem_node< T > vector_elem_node_t
Definition: exprtk.hpp:18147
ff11_functor f
Definition: exprtk.hpp:16145
opr_base< T >::RefType RefType
Definition: exprtk.hpp:12042
expression_node< T >::node_type type() const
Definition: exprtk.hpp:6653
Definition: exprtk.hpp:4406
T sinc_impl(T v, real_type_tag)
Definition: exprtk.hpp:1269
const range_t & range_ref() const
Definition: exprtk.hpp:8708
Definition: exprtk.hpp:18112
void register_local_vars(expression< T > &e)
Definition: exprtk.hpp:34392
Definition: exprtk.hpp:13094
details::T0oT1oT2oT3_define< T, cref_t, cref_t, cref_t, const_t > vovovoc_t
Definition: exprtk.hpp:18211
expression_node_t * expression_node_ptr
Definition: exprtk.hpp:18173
bool all_nodes_variables(Sequence< expression_node< T > *, Allocator > &b)
Definition: exprtk.hpp:5183
~cons_conditional_node()
Definition: exprtk.hpp:6054
Definition: exprtk.hpp:13190
bool cocob_optimisable(const details::operator_type &operation, expression_node_ptr(&branch)[2]) const
Definition: exprtk.hpp:25904
vector_view_impl operator=(const vector_view_impl &)
freefunc01(ff01_functor ff)
Definition: exprtk.hpp:16037
bool run_modifiers(lexer::generator &g)
Definition: exprtk.hpp:3849
bool add(const function &f, const bool override=false)
Definition: exprtk.hpp:35946
void pre()
Definition: exprtk.hpp:35593
Definition: exprtk.hpp:4422
string_concat_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:7862
Definition: exprtk.hpp:4913
expression_node< T >::node_type type() const
Definition: exprtk.hpp:7706
Definition: exprtk.hpp:3405
range_t & range_ref()
Definition: exprtk.hpp:7628
igeneric_function(const std::string ¶m_seq="", const return_type rtr_type=e_rtrn_scalar)
Definition: exprtk.hpp:15962
Definition: exprtk.hpp:38118
T0 t0_
Definition: exprtk.hpp:14296
unknown_symbol_resolver(const usr_mode m=e_usrmode_default)
Definition: exprtk.hpp:19015
Definition: exprtk.hpp:4452
bool enable_replacer_
Definition: exprtk.hpp:19789
bool add_vector(const std::string &vector_name, exprtk::vector_view< T > &v)
Definition: exprtk.hpp:17169
Definition: exprtk.hpp:4903
std::string value_
Definition: exprtk.hpp:8726
expression_node< T >::node_type type() const
Definition: exprtk.hpp:6202
Definition: exprtk.hpp:10325
expression_node< T >::node_type type() const
Definition: exprtk.hpp:9273
T and_impl(const T v0, const T v1, real_type_tag)
Definition: exprtk.hpp:1100
Definition: exprtk.hpp:2020
T derivative(const expression< T > &e, T &x, const T &h=T(0.00000001))
Definition: exprtk.hpp:34886
virtual T const T &virtual empty_method_body T const T const T const T &virtual empty_method_body T const T const T const T const T const T &virtual empty_method_body T const T const T const T const T const T const T const T &virtual empty_method_body T const T const T const T const T const T const T const T const T const T &virtual empty_method_body T const T const T const T const T const T const T const T const T const T const T const T &virtual empty_method_body T const T const T const T const T const T const T const T const T const T const T const T const T const T &virtual empty_method_body T const T const T const T const T const T const T const T const T const T const T const T const T const T const T const T &virtual empty_method_body T const T const T const T const T const T const T const T const T const T const T const T const T const T const T const T const T const T &virtual empty_method_body T const T const T const T const T const T const T const T const T const T const T const T const T const T const T const T const T const T const T const T &empty_method_body std::size_t param_count
Definition: exprtk.hpp:15923
opr_base< T >::RefType RefType
Definition: exprtk.hpp:12007
param_seq_list_t param_seq_list_
Definition: exprtk.hpp:23319
T value() const
Definition: exprtk.hpp:6148
range_t base_range_
Definition: exprtk.hpp:7843
bool is_constpow_operation(const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:25994
std::size_t size() const
Definition: exprtk.hpp:9878
functor_t::qfunc_t quaternary_functor_t
Definition: exprtk.hpp:9003
expression< T > & release()
Definition: exprtk.hpp:17745
symbol_table(const symbol_table< T > &st)
Definition: exprtk.hpp:16716
branch_t branch_[1]
Definition: exprtk.hpp:14649
lexer::token_scanner * error_token_scanner
Definition: exprtk.hpp:3942
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:37897
range_pack< T > range_t
Definition: exprtk.hpp:5552
Definition: exprtk.hpp:2021
~scoped_deq_delete()
Definition: exprtk.hpp:20758
Definition: exprtk.hpp:4394
T cot_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1304
std::size_t vector_size() const
Definition: exprtk.hpp:5304
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:31906
vector_node_ptr vec0_node_ptr_
Definition: exprtk.hpp:10500
Definition: exprtk.hpp:4410
Definition: exprtk.hpp:18105
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1)
Definition: exprtk.hpp:29648
Definition: exprtk.hpp:16073
virtual ~sf3ext_type_node()
Definition: exprtk.hpp:14032
T0oT1oT2oT3(node_type &)
Definition: exprtk.hpp:13933
str_base_ptr str0_base_ptr_
Definition: exprtk.hpp:8567
static T process(const Sequence< Type, Allocator > &arg_list)
Definition: exprtk.hpp:12426
std::string str() const
Definition: exprtk.hpp:8534
node_type::T1 T1
Definition: exprtk.hpp:30754
void cleanup()
Definition: exprtk.hpp:18457
static expression_node< T > * allocate(Allocator &allocator, T0 p0, T1 p1, T2 p2, tfunc_t p3)
Definition: exprtk.hpp:14009
bool & collect_functions()
Definition: exprtk.hpp:19142
swap_generic_node(expression_ptr var0, expression_ptr var1)
Definition: exprtk.hpp:7349
const T & v_
Definition: exprtk.hpp:14537
token & set_string(const Iterator begin, const Iterator end, const Iterator base_begin=Iterator(0))
Definition: exprtk.hpp:2079
void update(const T &v0, const T &v1)
Definition: exprtk.hpp:35520
Definition: exprtk.hpp:1362
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:31013
Definition: exprtk.hpp:10664
binary_ext_node(expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:5842
bool compile_expression(const std::string &name, const std::string &expression, const Sequence< std::string, Allocator > &input_var_list, bool return_present=false)
Definition: exprtk.hpp:35955
virtual bool operator()(const token &)
Definition: exprtk.hpp:2944
covovoc_t::type1 node_type
Definition: exprtk.hpp:32030
static const double _2_pi
Definition: exprtk.hpp:744
expression_node_ptr get_variable(const T &v)
Definition: exprtk.hpp:18474
static std::string id()
Definition: exprtk.hpp:13540
bool add(const std::string &symbol_name, RawType &t, const bool is_const=false)
Definition: exprtk.hpp:16363
T round_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1012
Definition: exprtk.hpp:8225
vovocov_t::sf4_type sf4_type
Definition: exprtk.hpp:32724
static T process_3(const Sequence &arg_list)
Definition: exprtk.hpp:12607
control_block * control_block_
Definition: exprtk.hpp:17915
covovoc_t::sf4_type sf4_type
Definition: exprtk.hpp:32537
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33180
static std::string result()
Definition: exprtk.hpp:13452
generic_type::parameter_list parameter_list_t
Definition: exprtk.hpp:11791
std::pair< expression_ptr, bool > branch_t
Definition: exprtk.hpp:14597
~for_loop_bc_node()
Definition: exprtk.hpp:6500
static bool cmp(const char_t c0, const char_t c1)
Definition: exprtk.hpp:567
static std::string id()
Definition: exprtk.hpp:14094
Definition: exprtk.hpp:2030
ror()
Definition: exprtk.hpp:37486
node_type::T2 T2
Definition: exprtk.hpp:32670
void set_ref(value_ptr *ref)
Definition: exprtk.hpp:5358
static T result(T v)
Definition: exprtk.hpp:1559
#define poly_rtrn(NN)
Definition: exprtk.hpp:35309
static T process(const T &t0, const T &t1, const T &t2, const T &t3, const bfunc_t bf0, const bfunc_t bf1, const bfunc_t bf2)
Definition: exprtk.hpp:13552
node_type::T2 T2
Definition: exprtk.hpp:31267
Definition: exprtk.hpp:18998
node_type::T3 T3
Definition: exprtk.hpp:30756
#define register_sf4ext(Op)
bool control_struct_disabled(const std::string &control_struct)
Definition: exprtk.hpp:19498
bool collect_functions_
Definition: exprtk.hpp:19211
details::T0oT1oT2_define< T, cref_t, cref_t, const_t > vovoc_t
Definition: exprtk.hpp:18203
#define exprtk_register_int_type_tag(T)
Definition: exprtk.hpp:772
token & set_numeric(const Iterator begin, const Iterator end, const Iterator base_begin=Iterator(0))
Definition: exprtk.hpp:2069
Definition: exprtk.hpp:4420
ff06_functor f
Definition: exprtk.hpp:16090
Definition: exprtk.hpp:4433
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:37105
~bipow_node()
Definition: exprtk.hpp:15177
const bool single_value_initialse_
Definition: exprtk.hpp:7308
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:37198
#define case_stmt(N)
Definition: exprtk.hpp:26605
expression_node< typename node_type::value_type > * allocate(const T1 &t1, const T2 &t2, const T3 &t3) const
Definition: exprtk.hpp:15545
Definition: exprtk.hpp:381
bool in_use() const
Definition: exprtk.hpp:36420
node_type::T2 T2
Definition: exprtk.hpp:33065
vovovov_t::sf4_type sf4_type
Definition: exprtk.hpp:31641
static T_ execute(ifunction &f, T_(&v)[11])
Definition: exprtk.hpp:11225
string_base_node< T > * str_base_ptr
Definition: exprtk.hpp:7728
Definition: exprtk.hpp:9481
std::vector< type_store_t > typestore_list_t
Definition: exprtk.hpp:11425
node_type::T0 T0
Definition: exprtk.hpp:31265
std::string & ref()
Definition: exprtk.hpp:7533
Definition: exprtk.hpp:4491
Definition: exprtk.hpp:4456
static T evaluate(const Type x, const Type c2, const Type c1, const Type c0)
Definition: exprtk.hpp:35279
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:31699
std::size_t min_num_args_
Definition: exprtk.hpp:15789
Definition: exprtk.hpp:2025
Definition: exprtk.hpp:4430
Definition: exprtk.hpp:4410
token_scanner(const std::size_t &stride)
Definition: exprtk.hpp:2869
node_type::T2 T2
Definition: exprtk.hpp:33121
static std::pair< bool, vector_t * > make(exprtk::vector_view< T > &v, const bool is_const=false)
Definition: exprtk.hpp:16315
expression_node< T > * expression_ptr
Definition: exprtk.hpp:10514
branch_t branch_[3]
Definition: exprtk.hpp:5937
Definition: exprtk.hpp:32777
functor_t::qfunc_t quaternary_functor_t
Definition: exprtk.hpp:18180
details::operator_type operation
Definition: exprtk.hpp:20406
bool rebaseable() const
Definition: exprtk.hpp:5428
bool is_conststr_stringvar(const std::string &symbol_name) const
Definition: exprtk.hpp:17351
Definition: exprtk.hpp:2027
Definition: exprtk.hpp:10174
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1)
Definition: exprtk.hpp:29768
RangePack rp0_
Definition: exprtk.hpp:14957
std::string str() const
Definition: exprtk.hpp:8942
range_interface< T > irange_t
Definition: exprtk.hpp:8079
bool is_uv_node(const expression_node< T > *node)
Definition: exprtk.hpp:15310
Definition: exprtk.hpp:7653
token & set_symbol(const Iterator begin, const Iterator end, const Iterator base_begin=Iterator(0))
Definition: exprtk.hpp:2059
T roundn_impl(const T v0, const T, int_type_tag)
Definition: exprtk.hpp:1030
expression_node< T > * branch(const std::size_t &) const
Definition: exprtk.hpp:5528
static details::operator_type operation()
Definition: exprtk.hpp:12180
bool add_element(const scope_element &se)
Definition: exprtk.hpp:18387
T0oT1oT2oT3_sf4< T, T0, T1, T2, T3 > node_type
Definition: exprtk.hpp:14139
Definition: exprtk.hpp:4925
results_context()
Definition: exprtk.hpp:4342
node_type::T1 T1
Definition: exprtk.hpp:33400
T value_type
Definition: exprtk.hpp:13763
vector_node< T > * vec1_node_ptr_
Definition: exprtk.hpp:10319
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:37151
static T process_1(const Sequence &arg_list)
Definition: exprtk.hpp:12454
covovov_t::sf4_type sf4_type
Definition: exprtk.hpp:30752
void disable_unknown_symbol_resolver()
Definition: exprtk.hpp:20214
bool sf3_optimisable(const std::string &sf3id, details::operator_type &operation)
Definition: exprtk.hpp:25671
functor_t::bfunc_t binary_functor_t
Definition: exprtk.hpp:18182
expression_node< T >::node_type type() const
Definition: exprtk.hpp:9419
bool commutative_check_enabled() const
Definition: exprtk.hpp:19426
string_literal_node(const std::string &v)
Definition: exprtk.hpp:5589
static T process_4(const Sequence &arg_list)
Definition: exprtk.hpp:12472
Definition: exprtk.hpp:4446
unary_variable_node< T, Operation > & operator=(unary_variable_node< T, Operation > &)
bool create_variable(const std::string &variable_name, const T &value=T(0))
Definition: exprtk.hpp:16942
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:33330
static T process_4(const Sequence &arg_list)
Definition: exprtk.hpp:12617
str_base_ptr str1_base_ptr_
Definition: exprtk.hpp:8722
static T process(const std::string &t1, const std::string &t2)
Definition: exprtk.hpp:12178
void clear()
Definition: exprtk.hpp:2202
vds_t vds_
Definition: exprtk.hpp:7477
virtual ~uv_base_node()
Definition: exprtk.hpp:13214
node_type::T2 T2
Definition: exprtk.hpp:33457
bool empty() const
Definition: exprtk.hpp:2232
cov_node(const T &const_var, const T &var)
Definition: exprtk.hpp:14405
func_0param()
Definition: exprtk.hpp:35713
Definition: exprtk.hpp:9750
sequence_vector_impl(sequence_t &seq)
Definition: exprtk.hpp:5325
expression_node_ptr parse_const_string()
Definition: exprtk.hpp:22876
Definition: exprtk.hpp:4923
virtual T operator()(const std::vector< T > &)
Definition: exprtk.hpp:15940
dotk< T > dtk
Definition: exprtk.hpp:38187
cached_range_t cache
Definition: exprtk.hpp:6946
Definition: exprtk.hpp:4918
vector_holder(Type *vec, const std::size_t &vec_size)
Definition: exprtk.hpp:5391
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:32317
~vec_data_store()
Definition: exprtk.hpp:4652
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:30389
std::size_t process(generator &g)
Definition: exprtk.hpp:3001
vovovoc_t::type3 node_type
Definition: exprtk.hpp:32666
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:31963
Definition: exprtk.hpp:4928
expression_node< T > * expression_ptr
Definition: exprtk.hpp:14895
bool is_bracket(const char_t c)
Definition: exprtk.hpp:142
std::size_t size() const
Definition: exprtk.hpp:4235
expression_node_ptr parse_continue_statement()
Definition: exprtk.hpp:23728
vec_data_store< T > vds_t
Definition: exprtk.hpp:7196
expression_node< T > * expression_ptr
Definition: exprtk.hpp:11351
data_type type
Definition: exprtk.hpp:17592
std::size_t process(generator &g)
Definition: exprtk.hpp:2878
strvar_node_ptr str0_node_ptr_
Definition: exprtk.hpp:8436
T ncdf_impl(T v, real_type_tag)
Definition: exprtk.hpp:1254
static const std::size_t assignment_ops_list_size
Definition: exprtk.hpp:489
node_type::T0 T0
Definition: exprtk.hpp:31919
std::size_t max_num_args_
Definition: exprtk.hpp:15790
#define exprtk_debug(params)
Definition: exprtk.hpp:64
node_type::T1 T1
Definition: exprtk.hpp:33456
std::vector< std::string > param_seq_list_t
Definition: exprtk.hpp:23134
node_type::T3 T3
Definition: exprtk.hpp:30504
details::char_cptr s_itr_
Definition: exprtk.hpp:2842
Definition: exprtk.hpp:28350
vector_elem_node(expression_ptr index, vector_holder_ptr vec_holder)
Definition: exprtk.hpp:7078
expression_node< T > * move_branch(const std::size_t &)
Definition: exprtk.hpp:14637
Definition: exprtk.hpp:4005
Definition: exprtk.hpp:4431
settings_store & disable_all_arithmetic_ops()
Definition: exprtk.hpp:19392
symbol_table_list_t symtab_list_
Definition: exprtk.hpp:18547
Definition: exprtk.hpp:4436
Definition: exprtk.hpp:29096
void set_strength_reduction_state(const bool enabled)
Definition: exprtk.hpp:25554
bool invalid_range(const Vector &v, const std::size_t r0, const std::size_t r1)
Definition: exprtk.hpp:37089
void add_symbol(const std::string &symbol, const symbol_type st)
Definition: exprtk.hpp:19171
const std::size_t index_
Definition: exprtk.hpp:7233
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:37380
bool is_string_vararg_node(const expression_node< T > *node)
Definition: exprtk.hpp:15370
Definition: exprtk.hpp:6480
const bfunc_t f0_
Definition: exprtk.hpp:13940
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:32149
virtual bool populate_value_list() const
Definition: exprtk.hpp:11551
expression_node< T > * expression_ptr
Definition: exprtk.hpp:9328
std::string * value_
Definition: exprtk.hpp:8251
ufunc_t u1()
Definition: exprtk.hpp:13366
void register_return_results(results_context_t *rc)
Definition: exprtk.hpp:17899
static T process(Type t1, Type t2, Type t3)
Definition: exprtk.hpp:12009
const bool loop_body_deletable_
Definition: exprtk.hpp:6582
static std::string id(expression_generator< Type > &, const details::operator_type, const details::operator_type, const details::operator_type)
Definition: exprtk.hpp:32601
~vararg_function_node()
Definition: exprtk.hpp:11361
covovoc_t::sf4_type sf4_type
Definition: exprtk.hpp:32031
static details::operator_type operation()
Definition: exprtk.hpp:12012
vococov_t::sf4_type sf4_type
Definition: exprtk.hpp:31453
range_ptr str0_range_ptr_
Definition: exprtk.hpp:8570
const results_context_t & results() const
Definition: exprtk.hpp:17794
static const std::string inequality_ops_list[]
Definition: exprtk.hpp:491
bool compile(const std::string &expression_string, expression< T > &expr)
Definition: exprtk.hpp:19916
token token_t
Definition: exprtk.hpp:3953
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:37695
void clear()
Definition: exprtk.hpp:35926
Definition: exprtk.hpp:4394
Definition: exprtk.hpp:5122
Definition: exprtk.hpp:4331
expression_ptr condition_
Definition: exprtk.hpp:6346
bool collect_assignments_enabled() const
Definition: exprtk.hpp:19434
std::string to_str(int i)
Definition: exprtk.hpp:261
T2 t2_
Definition: exprtk.hpp:14023
bool operator()(const lexer::token &t)
Definition: exprtk.hpp:3445
bool match_impl(const Iterator pattern_begin, const Iterator pattern_end, const Iterator data_begin, const Iterator data_end, const typename std::iterator_traits< Iterator >::value_type &zero_or_more, const typename std::iterator_traits< Iterator >::value_type &zero_or_one)
Definition: exprtk.hpp:582
node_type::T0 T0
Definition: exprtk.hpp:32538
std::size_t options_
Definition: exprtk.hpp:19209
expression_node< T >::node_type type() const
Definition: exprtk.hpp:10478
expression_node< T >::node_type type() const
Definition: exprtk.hpp:11544
node_type & operator=(node_type &)
Definition: exprtk.hpp:14019
inv_binary_op_map_t * inv_binary_op_map_
Definition: exprtk.hpp:34365
Definition: exprtk.hpp:4907
expression_node< T > * expression_ptr
Definition: exprtk.hpp:14496
value_ptr data() const
Definition: exprtk.hpp:5267
void load_sf3_map(sf3_map_t &sf3_map)
Definition: exprtk.hpp:34560
Definition: exprtk.hpp:17974
void clear()
Definition: exprtk.hpp:16767
const T & v() const
Definition: exprtk.hpp:14572
void set_parser(parser_t &p)
Definition: exprtk.hpp:25519
Definition: exprtk.hpp:5348
bool & b
Definition: exprtk.hpp:20822
bfunc_t f1() const
Definition: exprtk.hpp:13811
Definition: exprtk.hpp:6776
virtual ~range_interface()
Definition: exprtk.hpp:5554
Definition: exprtk.hpp:16172
bool special_one_parameter_vararg(const details::operator_type &operation)
Definition: exprtk.hpp:27075
Definition: exprtk.hpp:4427
expression_node_ptr synthesize_str_xrox_expression_impl(const details::operator_type &opr, T0 s0, T1 s1, range_t rp0)
Definition: exprtk.hpp:33671
bool symbol_exists(const std::string &symbol_name, const bool check_reserved_symb=true) const
Definition: exprtk.hpp:17309
const vds_t & vds() const
Definition: exprtk.hpp:10650
T value() const
Definition: exprtk.hpp:6383
node_type::T2 T2
Definition: exprtk.hpp:33234
~scoped_delete()
Definition: exprtk.hpp:20727
std::vector< ifunction< T > * > free_function_list_
Definition: exprtk.hpp:16653
Definition: exprtk.hpp:4900
Definition: exprtk.hpp:4408
Definition: exprtk.hpp:2988
const ufunc_t u1_
Definition: exprtk.hpp:13384
T2 t2() const
Definition: exprtk.hpp:13988
function_ptr get_function(const std::string &function_name) const
Definition: exprtk.hpp:16842
static details::operator_type operation()
Definition: exprtk.hpp:12046
static const double _1_pi
Definition: exprtk.hpp:743
static T process_1(const Sequence &arg_list)
Definition: exprtk.hpp:12328
Definition: exprtk.hpp:7188
bool add(const std::string &symbol_name, T *v, const std::size_t v_size, const bool is_const=false)
Definition: exprtk.hpp:16337
expression_node_ptr multi_switch_statement(Sequence< expression_node_ptr, Allocator > &arg_list)
Definition: exprtk.hpp:26732
Definition: exprtk.hpp:14828
bool initialised_
Definition: exprtk.hpp:7838
Definition: exprtk.hpp:4402
vovocov_t::type1 node_type
Definition: exprtk.hpp:31748
~boc_node()
Definition: exprtk.hpp:14668
Definition: exprtk.hpp:5548
ipow_node< T, PowOp > & operator=(const ipow_node< T, PowOp > &)
bool operator()(const std::string &s1, const std::string &s2) const
Definition: exprtk.hpp:199
const vds_t & vds() const
Definition: exprtk.hpp:10493
operator_type type
Definition: exprtk.hpp:4498
const_string_range_node< T > & operator=(const const_string_range_node< T > &)
Definition: exprtk.hpp:37522
results_context< T > results_context_t
Definition: exprtk.hpp:11808
node_type::T0 T0
Definition: exprtk.hpp:30669
bool is_reserved_symbol(const std::string &symbol) const
Definition: exprtk.hpp:16634
Definition: exprtk.hpp:5980
print< T > p
Definition: exprtk.hpp:36558
vector_holder_ptr temp_
Definition: exprtk.hpp:10502
range_t & range_ref()
Definition: exprtk.hpp:7821
const T & ref() const
Definition: exprtk.hpp:7164
virtual const T & v() const =0
Definition: exprtk.hpp:4151
symbol_table()
Definition: exprtk.hpp:16705
Definition: exprtk.hpp:4912
static bool compile(expression_generator< Type > &expr_gen, const std::string &id, T0 t0, T1 t1, T2 t2, expression_node_ptr &result)
Definition: exprtk.hpp:29202
static T null_value
Definition: exprtk.hpp:6781
vococov_t::sf4_type sf4_type
Definition: exprtk.hpp:33062
~scope_handler()
Definition: exprtk.hpp:18526
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:31867
vector_node< T > * vector_node_ptr
Definition: exprtk.hpp:10057
expression_node< T >::node_type type() const
Definition: exprtk.hpp:11648
~parser()
Definition: exprtk.hpp:19850
static std::string id()
Definition: exprtk.hpp:13475
Definition: exprtk.hpp:4407
node_type::T0 T0
Definition: exprtk.hpp:33455
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:29780
Definition: exprtk.hpp:15076
static T process(Type t1, Type t2)
Definition: exprtk.hpp:12073
Definition: exprtk.hpp:4395
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:36891
static T process(const std::string &t1, const std::string &t2)
Definition: exprtk.hpp:12064
expression_node< T > * branch(const std::size_t &) const
Definition: exprtk.hpp:5687
static T process(Type t1, Type t2)
Definition: exprtk.hpp:12032
Definition: exprtk.hpp:15406
opr_base< T >::Type Type
Definition: exprtk.hpp:12131
stringvar_node(std::string &v)
Definition: exprtk.hpp:7496
static const std::string reserved_symbols[]
Definition: exprtk.hpp:428
details::variable_node< T > variable_node_t
Definition: exprtk.hpp:18146
typestore_list_t typestore_list_
Definition: exprtk.hpp:11589
expression_node_ptr parse_ternary_conditional_statement(expression_node_ptr condition)
Definition: exprtk.hpp:21453
RangePack rp0_
Definition: exprtk.hpp:14819
static const double pow10[]
Definition: exprtk.hpp:724
Definition: exprtk.hpp:4412
bool register_package(exprtk::symbol_table< T > &symtab)
Definition: exprtk.hpp:36561
Definition: exprtk.hpp:9289
expression()
Definition: exprtk.hpp:17687
node_type::T1 T1
Definition: exprtk.hpp:30385
range_t & range_ref()
Definition: exprtk.hpp:7543
freefunc03(ff03_functor ff)
Definition: exprtk.hpp:16057
vector_elem_node< T > * vec_node_ptr_
Definition: exprtk.hpp:9973
qfunc_t f() const
Definition: exprtk.hpp:14185
node_type::T0 T0
Definition: exprtk.hpp:33063
static bool test(const variable_node_t *p, const void *ptr)
Definition: exprtk.hpp:16428
generic_type::vector_view vector_t
Definition: exprtk.hpp:37200
node_type::T3 T3
Definition: exprtk.hpp:32840
PowOp operation_t
Definition: exprtk.hpp:15170
null_igenfunc< T > igeneric_function_t
Definition: exprtk.hpp:11805
Definition: exprtk.hpp:29072
settings_store & enable_assignment_operation(settings_assignment_opr assignment)
Definition: exprtk.hpp:19691
#define define_sfop4(NN, OP0, OP1)
static T evaluate(const Type x, const Type c9, const Type c8, const Type c7, const Type c6, const Type c5, const Type c4, const Type c3, const Type c2, const Type c1, const Type c0)
Definition: exprtk.hpp:35199
Definition: exprtk.hpp:6144
T value() const
Definition: exprtk.hpp:14248
Definition: exprtk.hpp:4901
range_t & range_ref()
Definition: exprtk.hpp:11668
Definition: exprtk.hpp:16148
Definition: exprtk.hpp:4422
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:32430
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:38122
T value() const
Definition: exprtk.hpp:15212
void set_retinvk(bool *retinvk_ptr)
Definition: exprtk.hpp:17907
control_block * control_block_
Definition: exprtk.hpp:4742
Definition: exprtk.hpp:2026
bool register_package(exprtk::symbol_table< T > &symtab)
Definition: exprtk.hpp:37052
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:29900
str_base_ptr str0_base_ptr_
Definition: exprtk.hpp:8217
bool side_effect_present
Definition: exprtk.hpp:18991
Definition: exprtk.hpp:4933
expression_node< T >::node_type type() const
Definition: exprtk.hpp:6404
Type value_type
Definition: exprtk.hpp:5247
vararg_function_ptr get_vararg_function(const std::string &vararg_function_name) const
Definition: exprtk.hpp:18682
std::size_t param_seq_index_
Definition: exprtk.hpp:11725
Definition: exprtk.hpp:13466
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:37832
node_type::T2 T2
Definition: exprtk.hpp:33290
virtual std::string type_id() const =0
assignment_vec_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:9642
Definition: exprtk.hpp:4402
vovoc_t::sf3_type sf3_type
Definition: exprtk.hpp:29598
Definition: exprtk.hpp:12039
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:28437
stringvar_node_ptr str_node
Definition: exprtk.hpp:18309
void set_uom(unary_op_map_t &unary_op_map)
Definition: exprtk.hpp:25524
function_N_node(ifunction *func)
Definition: exprtk.hpp:11319
scope_element & get_active_element(const std::string &var_name, const std::size_t index=std::numeric_limits< std::size_t >::max())
Definition: exprtk.hpp:18365
~while_loop_node()
Definition: exprtk.hpp:6177
functor_t::bfunc_t bfunc_t
Definition: exprtk.hpp:13695
virtual ~bov_base_node()
Definition: exprtk.hpp:13163
std::string str() const
Definition: exprtk.hpp:5613
Definition: exprtk.hpp:2019
vec_binop_valvec_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:10674
node_type & operator=(node_type &)
Definition: exprtk.hpp:13934
static void destroy(control_block *&cntrl_blck)
Definition: exprtk.hpp:4597
bool valid_function_name(const std::string &symbol) const
Definition: exprtk.hpp:18591
void kahan_sum(T &sum, T &error, T v)
Definition: exprtk.hpp:37136
strbase_ptr_t str_node
Definition: exprtk.hpp:6970
T value_type
Definition: exprtk.hpp:14227
const bool condition_deletable_
Definition: exprtk.hpp:6475
lexer::token_modifier * error_token_modifier
Definition: exprtk.hpp:3943
generic_type::scalar_view scalar_t
Definition: exprtk.hpp:37433
freefunc06(ff06_functor ff)
Definition: exprtk.hpp:16087
~unary_branch_node()
Definition: exprtk.hpp:13401
Definition: exprtk.hpp:6357
vector_node< T > * vector_node_ptr
Definition: exprtk.hpp:10515
vec_data_store(const std::size_t &size, data_t data, bool dstrct=false)
Definition: exprtk.hpp:4642
branch_t branch_[1]
Definition: exprtk.hpp:14588
Definition: exprtk.hpp:4404
std::string value_
Definition: exprtk.hpp:7845
Definition: exprtk.hpp:30009
bool is_neg_unary_node(const expression_node< T > *node)
Definition: exprtk.hpp:5003
T modulus(const T v0, const T v1)
Definition: exprtk.hpp:1419
expression_node_ptr synthesize_sos_expression_impl(const details::operator_type &opr, T0 s0, T1 s1)
Definition: exprtk.hpp:33725
Definition: exprtk.hpp:20711
settings_store & enable_all_logic_ops()
Definition: exprtk.hpp:19335
Definition: exprtk.hpp:4918
Definition: exprtk.hpp:2851
node_type::T2 T2
Definition: exprtk.hpp:31028
details::T0oT1oT2oT3< T, T0, T1, T2, T3, typename T0oT1oT20T3process< T >::mode2 > type2
Definition: exprtk.hpp:14340
bool valid() const
Definition: exprtk.hpp:17413
expression_node< T > * expression_ptr
Definition: exprtk.hpp:7074
exprtk_define_erf(float,::erff) exprtk_define_erf(double
void set_allocator(details::node_allocator &na)
Definition: exprtk.hpp:25549
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:32936
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:30824
std::size_t size() const
Definition: exprtk.hpp:5413
Definition: exprtk.hpp:4425
Definition: exprtk.hpp:4425
Definition: exprtk.hpp:33508
void load_binary_operations_map(binary_op_map_t &m)
Definition: exprtk.hpp:34504
generic_function_t * generic_function_ptr
Definition: exprtk.hpp:16594
const T & v0()
Definition: exprtk.hpp:13351
Definition: exprtk.hpp:17570
stringvar_size_node(std::string &v)
Definition: exprtk.hpp:8235
type_store_t::parameter_list parameter_list_t
Definition: exprtk.hpp:4372
bool delete_ptr
Definition: exprtk.hpp:20804
#define exprtk_error_location
Definition: exprtk.hpp:67
bool is_null_node(const expression_node< T > *node)
Definition: exprtk.hpp:5087
string_range_node(std::string &v, const range_t &rp)
Definition: exprtk.hpp:7578
Definition: exprtk.hpp:4440
Definition: exprtk.hpp:4922
expression_node_ptr synthesize_string_expression(const details::operator_type &opr, expression_node_ptr(&branch)[3])
Definition: exprtk.hpp:34072
node_type::T3 T3
Definition: exprtk.hpp:30588
Definition: exprtk.hpp:5780
bool delete_ptr
Definition: exprtk.hpp:20771
void copy(const lvr_vec_t &src_v, var_t &dest_v)
Definition: exprtk.hpp:35647
bool * retinvk_ptr()
Definition: exprtk.hpp:11888
T value() const
Definition: exprtk.hpp:5800
bool is_conststr_stringvar(const std::string &symbol_name) const
Definition: exprtk.hpp:18848
functor_t::tfunc_t tfunc_t
Definition: exprtk.hpp:13951
std::set< token_pair_t > set_t
Definition: exprtk.hpp:3625
range_t * range_ptr
Definition: exprtk.hpp:8451
void store()
Definition: exprtk.hpp:2248
vector_holder_ptr temp_
Definition: exprtk.hpp:10813
Definition: exprtk.hpp:4457
Definition: exprtk.hpp:20825
Definition: exprtk.hpp:4428
Definition: exprtk.hpp:4934
ufunc_t u0()
Definition: exprtk.hpp:13361
Definition: exprtk.hpp:4919
Definition: exprtk.hpp:8071
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:32582
Definition: exprtk.hpp:6587
Definition: exprtk.hpp:19252
vovovov_t::type2 node_type
Definition: exprtk.hpp:32142
static details::operator_type operation()
Definition: exprtk.hpp:12086
details::T0oT1oT2oT3_define< T, cref_t, const_t, cref_t, cref_t > vocovov_t
Definition: exprtk.hpp:18213
static const std::string reserved_words[]
Definition: exprtk.hpp:417
static T process_3(const Sequence &arg_list)
Definition: exprtk.hpp:12687
token_t & peek_next_token()
Definition: exprtk.hpp:2268
Definition: exprtk.hpp:29474
bool is_const_string_node(const expression_node< T > *node)
Definition: exprtk.hpp:15328
Definition: exprtk.hpp:6665
scope_element_manager(parser< T > &p)
Definition: exprtk.hpp:18321
igfun_t::generic_type generic_type
Definition: exprtk.hpp:37979
range_t range_
Definition: exprtk.hpp:7844
Definition: exprtk.hpp:4930
Definition: exprtk.hpp:31022
expression_ptr loop_body_
Definition: exprtk.hpp:6474
Definition: exprtk.hpp:2020
varref_t v
Definition: exprtk.hpp:35699
vector_node_t * vector_node_ptr_t
Definition: exprtk.hpp:11418
vector_holder< T > vector_holder_t
Definition: exprtk.hpp:7006
expression_node< T >::node_type type() const
Definition: exprtk.hpp:5603
Definition: exprtk.hpp:31690
str_xroxr_node(SType0 p0, SType1 p1, RangePack rp0, RangePack rp1)
Definition: exprtk.hpp:14899
assignment_vec_op_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:10060
T2_ T2
Definition: exprtk.hpp:13856
vector_node_ptr temp_vec_node_
Definition: exprtk.hpp:10814
std::size_t size() const
Definition: exprtk.hpp:7955
std::vector< unsigned char > delete_branch_
Definition: exprtk.hpp:6661
Definition: exprtk.hpp:4924
T value() const
Definition: exprtk.hpp:9302
bool is_nan(const T v)
Definition: exprtk.hpp:1384
vococov_t::sf4_type sf4_type
Definition: exprtk.hpp:32087
functor_t::tfunc_t trinary_functor_t
Definition: exprtk.hpp:9004
type_store< ivararg_function< T >, ivararg_function< T > > vararg_function_store
Definition: exprtk.hpp:16608
Definition: exprtk.hpp:37785
Definition: exprtk.hpp:4428
Definition: exprtk.hpp:5941
node_type::T1 T1
Definition: exprtk.hpp:32894
vocovov_t::type2 node_type
Definition: exprtk.hpp:32310
range_t rp_
Definition: exprtk.hpp:7646
bool is_vector(const std::string &vector_name) const
Definition: exprtk.hpp:17383
std::set< std::string, details::ilesscompare > disabled_entity_set_t
Definition: exprtk.hpp:19226
vocov_t::type1 node_type
Definition: exprtk.hpp:29717
details::repeat_until_loop_node< T > repeat_until_loop_node_t
Definition: exprtk.hpp:18138
multimode_strfunction_node(StringFunction *func, const std::size_t ¶m_seq_index, const std::vector< typename str_function_t::expression_ptr > &arg_list)
Definition: exprtk.hpp:11737
std::vector< lexer::token_scanner * > token_scanner_list
Definition: exprtk.hpp:3937
igfun_t::generic_type generic_type
Definition: exprtk.hpp:38030
expression_node_ptr synthesize_csos_expression(const details::operator_type &opr, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33812
virtual expression_node< T > * move_branch(const std::size_t &index)=0
T0oT1oT2oT3_sf4ext(T0 p0, T1 p1, T2 p2, T3 p3)
Definition: exprtk.hpp:14230
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33517
Definition: exprtk.hpp:13265
static T result(T v)
Definition: exprtk.hpp:1560
details::T0oT1oT2oT3_define< T, cref_t, cref_t, const_t, cref_t > vovocov_t
Definition: exprtk.hpp:18212
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1)
Definition: exprtk.hpp:29828
vararg_function_t * vararg_function_ptr
Definition: exprtk.hpp:16593
const range_t & range_ref() const
Definition: exprtk.hpp:11673
T value() const
Definition: exprtk.hpp:7355
igeneric_function< T > GF
Definition: exprtk.hpp:18125
#define exprtk_register_function(FunctionName, FunctionType)
bool is_vector_eqineq_logic_operation(const details::operator_type &operation, expression_node_ptr(&branch)[2]) const
Definition: exprtk.hpp:26101
Definition: exprtk.hpp:6090
Definition: exprtk.hpp:4913
Definition: exprtk.hpp:6216
std::size_t size() const
Definition: exprtk.hpp:9728
static const std::size_t reserved_words_size
Definition: exprtk.hpp:426
void split(const std::string &s)
Definition: exprtk.hpp:23231
char_cptr base() const
Definition: exprtk.hpp:5618
expression_ptr initialiser_
Definition: exprtk.hpp:6345
Definition: exprtk.hpp:19262
T nequal_impl(const T v0, const T v1, int_type_tag)
Definition: exprtk.hpp:923
bool disable_vardef_
Definition: exprtk.hpp:19799
virtual node_type type() const
Definition: exprtk.hpp:4954
static bool parse_nan(Iterator &itr, const Iterator end, T &t)
Definition: exprtk.hpp:1753
operator_type operation() const
Definition: exprtk.hpp:13297
~binary_ext_node()
Definition: exprtk.hpp:5847
token_list_t token_list_
Definition: exprtk.hpp:2837
generic_type::string_view string_t
Definition: exprtk.hpp:37641
generic_type::scalar_view scalar_t
Definition: exprtk.hpp:38125
std::size_t process_stride_2(generator &g)
Definition: exprtk.hpp:3100
T0oT1oT2(node_type &)
Definition: exprtk.hpp:13836
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:33556
str_base_ptr str0_base_ptr_
Definition: exprtk.hpp:7978
T value(details::expression_node< T > *n)
Definition: exprtk.hpp:12217
Definition: exprtk.hpp:4901
std::size_t size() const
Definition: exprtk.hpp:4177
bool is_string_concat_node(const expression_node< T > *node)
Definition: exprtk.hpp:15346
Definition: exprtk.hpp:13159
axpyz()
Definition: exprtk.hpp:37935
std::vector< scope_element > element_
Definition: exprtk.hpp:18503
bool operator==(const symbol_table< T > &st) const
Definition: exprtk.hpp:16735
T2 t2() const
Definition: exprtk.hpp:13886
T abs_impl(const T v, real_type_tag)
Definition: exprtk.hpp:855
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:37478
range_t * range_ptr
Definition: exprtk.hpp:8335
Definition: exprtk.hpp:29775
std::size_t get_variable_list(Sequence< std::pair< std::string, T >, Allocator > &vlist) const
Definition: exprtk.hpp:17259
Definition: exprtk.hpp:14321
expression_node< T > * expression_ptr
Definition: exprtk.hpp:15205
Definition: exprtk.hpp:11090
assignment_vecvec_op_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:10183
vocovov_t::type4 node_type
Definition: exprtk.hpp:33286
expression_node< T >::node_type type() const
Definition: exprtk.hpp:8426
expression_node< typename node_type::value_type > * allocate_type(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) const
Definition: exprtk.hpp:15665
Definition: exprtk.hpp:19258
data_t data() const
Definition: exprtk.hpp:4683
std::map< std::string, std::pair< std::string, token::token_type >, details::ilesscompare > replace_map_t
Definition: exprtk.hpp:3557
Definition: exprtk.hpp:4929
T value() const
Definition: exprtk.hpp:8127
vector_view_impl(vector_view_t &vec_view)
Definition: exprtk.hpp:5354
Definition: exprtk.hpp:11409
Definition: exprtk.hpp:19306
const T c_
Definition: exprtk.hpp:14648
Definition: exprtk.hpp:12138
Definition: exprtk.hpp:1362
std::pair< expression_ptr, bool > branch_t
Definition: exprtk.hpp:14547
Definition: exprtk.hpp:13112
Definition: exprtk.hpp:4405
rebasevector_celem_node< T > * rbvec_node_ptr_
Definition: exprtk.hpp:10047
ifunction< T > ifunction_t
Definition: exprtk.hpp:18126
operator_type operation()
Definition: exprtk.hpp:5813
void rebase(data_ptr_t data)
Definition: exprtk.hpp:4082
sf4_var_node(const T &v0, const T &v1, const T &v2, const T &v3)
Definition: exprtk.hpp:9295
T value() const
Definition: exprtk.hpp:6796
settings_store & enable_all_assignment_ops()
Definition: exprtk.hpp:19347
bool join(const lexer::token &t0, const lexer::token &t1, lexer::token &t)
Definition: exprtk.hpp:3240
static T result(T v)
Definition: exprtk.hpp:1557
bool disable_rsrvd_sym_usr_
Definition: exprtk.hpp:19800
std::string get_stringvar_name(const expression_node_ptr &ptr) const
Definition: exprtk.hpp:18930
T & ref()
Definition: exprtk.hpp:7159
virtual expression_node< T > * move_branch(const std::size_t &index)=0
T second_derivative(const expression< T > &e, T &x, const T &h=T(0.00001))
Definition: exprtk.hpp:34907
opr_base< T >::Type Type
Definition: exprtk.hpp:12167
Definition: exprtk.hpp:30749
opr_base< T >::RefType RefType
Definition: exprtk.hpp:12019
Definition: exprtk.hpp:3074
generic_type::scalar_view scalar_t
Definition: exprtk.hpp:36952
settings_store settings_
Definition: exprtk.hpp:34652
Definition: exprtk.hpp:32252
void dump() const
Definition: exprtk.hpp:4703
expression_node< T > * expression_ptr
Definition: exprtk.hpp:9907
void free_element(scope_element &se)
Definition: exprtk.hpp:18430
vector_holder_t * vector_holder_ptr
Definition: exprtk.hpp:7134
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:31755
bool control_struct_enabled(const std::string &control_struct)
Definition: exprtk.hpp:19447
node_type::T1 T1
Definition: exprtk.hpp:33513
element_type
Definition: exprtk.hpp:18227
void load_unary_operations_map(unary_op_map_t &m)
Definition: exprtk.hpp:34457
results_context< T > results_context_t
Definition: exprtk.hpp:17597
parser< T > & parser_
Definition: exprtk.hpp:20739
details::variable_node< T > variable_t
Definition: exprtk.hpp:16582
vector_node_ptr vec() const
Definition: exprtk.hpp:10468
stringvar_node< T > * strvar_node_ptr
Definition: exprtk.hpp:8332
node_type::T1 T1
Definition: exprtk.hpp:33176
static std::string null_value
Definition: exprtk.hpp:7576
scoped_bft(BaseFuncType &bft)
Definition: exprtk.hpp:35726
const T1 const T2
Definition: exprtk.hpp:13650
exprtk::ifunction< T > function_t
Definition: exprtk.hpp:35496
std::size_t column_no
Definition: exprtk.hpp:17992
Definition: exprtk.hpp:17572
Definition: exprtk.hpp:13847
vov_node< T, Operation > & operator=(vov_node< T, Operation > &)
std::map< std::string, expression_t > expr_map_
Definition: exprtk.hpp:36128
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:32993
void insert_front(token_t::token_type tk_type)
Definition: exprtk.hpp:2299
vector_node(const vds_t &vds, vector_holder_t *vh)
Definition: exprtk.hpp:7017
Definition: exprtk.hpp:3949
std::size_t size() const
Definition: exprtk.hpp:8818
expression_node< T > * expression_ptr
Definition: exprtk.hpp:5460
Definition: exprtk.hpp:18107
std::size_t size() const
Definition: exprtk.hpp:4693
control_block()
Definition: exprtk.hpp:4553
T log10_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1295
type_map_t::iterator tm_itr_t
Definition: exprtk.hpp:16213
vararg_varnode(const Sequence< expression_ptr, Allocator > &arg_list)
Definition: exprtk.hpp:9392
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:37479
void update(const T &v0, const T &v1, const T &v2, const T &v3)
Definition: exprtk.hpp:35531
range_t * range
Definition: exprtk.hpp:6966
bool is_constant_node(const std::string &symbol_name) const
Definition: exprtk.hpp:18766
T value() const
Definition: exprtk.hpp:14847
const std::size_t size_
Definition: exprtk.hpp:5314
vds_t vds_
Definition: exprtk.hpp:10660
Definition: exprtk.hpp:2026
Definition: exprtk.hpp:9633
value_ptr operator[](const std::size_t &index) const
Definition: exprtk.hpp:5257
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:32712
variable_node< T > * variable_node_ptr
Definition: exprtk.hpp:7317
str_base_ptr str0_base_ptr_
Definition: exprtk.hpp:8434
type_store< T > type_store_t
Definition: exprtk.hpp:4340
static T evaluate(const Type x, const Type c1, const Type c0)
Definition: exprtk.hpp:35289
T value() const
Definition: exprtk.hpp:9364
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:28352
generic_function_node< T, StringFunction > gen_function_t
Definition: exprtk.hpp:11607
print(const std::string &scalar_format="%10.5f")
Definition: exprtk.hpp:36517
Definition: exprtk.hpp:2022
void load_sf4_map(sf4_map_t &sf4_map)
Definition: exprtk.hpp:34584
Definition: exprtk.hpp:4915
T atanh_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1288
range_pack< T > range_t
Definition: exprtk.hpp:7857
static expression_node_ptr process(expression_generator< Type > &, const details::operator_type &, expression_node_ptr(&)[2])
Definition: exprtk.hpp:30372
static T process(Type t1, Type t2)
Definition: exprtk.hpp:12043
data_type
Definition: exprtk.hpp:17567
#define extended_opr_switch_statements
Definition: exprtk.hpp:28020
settings_store & disable_local_vardef()
Definition: exprtk.hpp:19419
T3_ T3
Definition: exprtk.hpp:13857
std::pair< expression_ptr, bool > branch_t
Definition: exprtk.hpp:5891
node_type::T0 T0
Definition: exprtk.hpp:33343
Operation operation_t
Definition: exprtk.hpp:14452
SType0 s0_
Definition: exprtk.hpp:14755
static const std::size_t inequality_ops_list_size
Definition: exprtk.hpp:498
ifunction * function_
Definition: exprtk.hpp:11306
Operation operation_t
Definition: exprtk.hpp:14548
T max_impl(const T v0, const T v1, real_type_tag)
Definition: exprtk.hpp:867
Definition: exprtk.hpp:13240
~repeat_until_loop_node()
Definition: exprtk.hpp:6229
return_type
Definition: exprtk.hpp:15952
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:32355
vector_elem_node< T > * vec_node_ptr_
Definition: exprtk.hpp:9553
expression_ptr branch_
Definition: exprtk.hpp:5504
ts_list_t parameter_list_
Definition: exprtk.hpp:4381
T0oT1oT2oT3< T, T0, T1, T2, T3, ProcessMode > node_type
Definition: exprtk.hpp:13858
bool active
Definition: exprtk.hpp:18304
covoc_t::type0 node_type
Definition: exprtk.hpp:29897
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:31681
Definition: exprtk.hpp:4441
T1 t1_
Definition: exprtk.hpp:14022
strvar_node_ptr str1_node_ptr_
Definition: exprtk.hpp:8067
expression_node< T > * branch(const std::size_t &) const
Definition: exprtk.hpp:14693
Definition: exprtk.hpp:4421
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:33050
virtual bool process(const std::string &, usr_symbol_type &st, T &default_value, std::string &error_message)
Definition: exprtk.hpp:19022
freefunc08(ff08_functor ff)
Definition: exprtk.hpp:16108
~quaternary_node()
Definition: exprtk.hpp:5958
PowOp operation_t
Definition: exprtk.hpp:15206
expression_node< T > * move_branch(const std::size_t &)
Definition: exprtk.hpp:14698
vec_data_store< T > type
Definition: exprtk.hpp:4546
RangePack rp1_
Definition: exprtk.hpp:14882
vovov_t::type1 node_type
Definition: exprtk.hpp:29476
parser(const settings_t &settings=settings_t())
Definition: exprtk.hpp:19815
expression_node< T > * expression_ptr
Definition: exprtk.hpp:10669
token_list_itr_t token_itr_
Definition: exprtk.hpp:2838
settings_store & disable_all_base_functions()
Definition: exprtk.hpp:19365
Definition: exprtk.hpp:14132
bool token_is(const token_t::token_type &ttype, const std::string &value, const token_advance_mode mode=e_advance)
Definition: exprtk.hpp:4028
Definition: exprtk.hpp:18117
function_t * function_ptr
Definition: exprtk.hpp:16592
static void assign(RefType t1, Type t2)
Definition: exprtk.hpp:12033
expression_node_ptr conditional(expression_node_ptr condition, expression_node_ptr consequent, expression_node_ptr alternative) const
Definition: exprtk.hpp:26307
irange_t * irange_ptr
Definition: exprtk.hpp:8080
~cob_node()
Definition: exprtk.hpp:14607
T value() const
Definition: exprtk.hpp:7593
range_ptr str1_range_ptr_
Definition: exprtk.hpp:15072
T value() const
Definition: exprtk.hpp:8778
vector_holder(const vds_t &vds)
Definition: exprtk.hpp:5395
std::size_t error_index(const std::size_t &i)
Definition: exprtk.hpp:3534
dotk()
Definition: exprtk.hpp:38130
scope_element & get_element(const std::string &var_name, const std::size_t index=std::numeric_limits< std::size_t >::max())
Definition: exprtk.hpp:18344
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:32243
static T_ execute(ifunction &f, T_(&v)[18])
Definition: exprtk.hpp:11176
exprtk_define_unary_op(abs) exprtk_define_unary_op(acos) exprtk_define_unary_op(acosh) exprtk_define_unary_op(asin) exprtk_define_unary_op(asinh) exprtk_define_unary_op(atan) exprtk_define_unary_op(atanh) exprtk_define_unary_op(ceil) exprtk_define_unary_op(cos) exprtk_define_unary_op(cosh) exprtk_define_unary_op(cot) exprtk_define_unary_op(csc) exprtk_define_unary_op(d2g) exprtk_define_unary_op(d2r) exprtk_define_unary_op(erf) exprtk_define_unary_op(erfc) exprtk_define_unary_op(exp) exprtk_define_unary_op(expm1) exprtk_define_unary_op(floor) exprtk_define_unary_op(frac) exprtk_define_unary_op(g2d) exprtk_define_unary_op(log) exprtk_define_unary_op(log10) exprtk_define_unary_op(log2) exprtk_define_unary_op(log1p) exprtk_define_unary_op(ncdf) exprtk_define_unary_op(neg) exprtk_define_unary_op(notl) exprtk_define_unary_op(pos) exprtk_define_unary_op(r2d) exprtk_define_unary_op(round) exprtk_define_unary_op(sec) exprtk_define_unary_op(sgn) exprtk_define_unary_op(sin) exprtk_define_unary_op(sinc) exprtk_define_unary_op(sinh) exprtk_define_unary_op(sqrt) exprtk_define_unary_op(tan) exprtk_define_unary_op(tanh) exprtk_define_unary_op(trunc) template< typename T > struct opr_base
Definition: exprtk.hpp:11925
expression_ptr incrementor_
Definition: exprtk.hpp:6577
int_type_tag()
Definition: exprtk.hpp:755
type_view< char > string_view
Definition: exprtk.hpp:4268
T value() const
Definition: exprtk.hpp:15182
range_ptr str1_range_ptr_
Definition: exprtk.hpp:8571
std::size_t count() const
Definition: exprtk.hpp:4346
disabled_entity_set_t disabled_arithmetic_set_
Definition: exprtk.hpp:19806
ifunction< T > function_t
Definition: exprtk.hpp:16589
Definition: exprtk.hpp:15954
stringvar_node< T > * strvar_node_ptr
Definition: exprtk.hpp:7994
Definition: exprtk.hpp:26650
Definition: exprtk.hpp:17972
vector_node< T > * vector_node_ptr
Definition: exprtk.hpp:7007
expression_node< T > * expression_ptr
Definition: exprtk.hpp:14546
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t t(t/t)") define_sfop3(19
expression_node_ptr var_node
Definition: exprtk.hpp:18306
const T & v0_
Definition: exprtk.hpp:14387
static T process_2(const Sequence &arg_list)
Definition: exprtk.hpp:12334
Definition: exprtk.hpp:2023
T1 t1_
Definition: exprtk.hpp:13937
expression_node_ptr parse_repeat_until_loop()
Definition: exprtk.hpp:21632
parser_state()
Definition: exprtk.hpp:18959
vector_holder_base * vector_holder_base_
Definition: exprtk.hpp:5435
T exp_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1292
Definition: exprtk.hpp:16321
Definition: exprtk.hpp:4141
range_pack< T > range_t
Definition: exprtk.hpp:8450
expression_node< T >::node_type type() const
Definition: exprtk.hpp:8300
expression_node< T > * expression_ptr
Definition: exprtk.hpp:9434
vovovov_t::type0 node_type
Definition: exprtk.hpp:30382
void scan_symbol()
Definition: exprtk.hpp:2561
expression_node_ptr synthesize_strogen_expression(const details::operator_type &opr, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33968
virtual value_ptr value_at(const std::size_t &) const =0
vococ_t::type0 node_type
Definition: exprtk.hpp:30248
T value(T *t)
Definition: exprtk.hpp:12223
bool initialised_
Definition: exprtk.hpp:8221
std::vector< std::size_t > error_list_
Definition: exprtk.hpp:3550
expression_node< T >::node_type type() const
Definition: exprtk.hpp:13705
functor_t::bfunc_t binary_functor_t
Definition: exprtk.hpp:9005
std::map< std::string, std::pair< quaternary_functor_t, operator_t > > sf4_map_t
Definition: exprtk.hpp:18192
std::string & stringvar_ref(const std::string &symbol_name)
Definition: exprtk.hpp:16906
opr_base< T >::RefType RefType
Definition: exprtk.hpp:11995
functor_t::bfunc_t bfunc_t
Definition: exprtk.hpp:13762
Definition: exprtk.hpp:4428
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:36949
ff05_functor f
Definition: exprtk.hpp:16080
Definition: exprtk.hpp:11601
bool empty() const
Definition: exprtk.hpp:18331
opr_base< T >::Type Type
Definition: exprtk.hpp:12196
static T process(const std::string &t1, const std::string &t2)
Definition: exprtk.hpp:12104
igfun_t::generic_type generic_type
Definition: exprtk.hpp:37929
static details::operator_type operation()
Definition: exprtk.hpp:12213
vocovoc_t::sf4_type sf4_type
Definition: exprtk.hpp:32481
exprtk_register_real_type_tag(double) exprtk_register_real_type_tag(long double) exprtk_register_real_type_tag(float) exprtk_register_complex_type_tag(double) exprtk_register_complex_type_tag(long double) exprtk_register_complex_type_tag(float) exprtk_register_int_type_tag(short) exprtk_register_int_type_tag(int) exprtk_register_int_type_tag(long long int) exprtk_register_int_type_tag(unsigned short) exprtk_register_int_type_tag(unsigned int) exprtk_register_int_type_tag(unsigned long long int) template< typename T > struct epsilon_type
Definition: exprtk.hpp:776
Definition: exprtk.hpp:4929
scope_element()
Definition: exprtk.hpp:18244
Definition: exprtk.hpp:4457
expression_node< T > * expression_ptr
Definition: exprtk.hpp:11414
static T process_2(const Sequence &arg_list)
Definition: exprtk.hpp:12391
Definition: exprtk.hpp:4434
Definition: exprtk.hpp:8441
T0oT1oT2_sf3(T0 p0, T1 p1, T2 p2, const tfunc_t p3)
Definition: exprtk.hpp:13955
opr_base< T >::Type Type
Definition: exprtk.hpp:12018
Definition: exprtk.hpp:4409
bracket_checker()
Definition: exprtk.hpp:3411
expression_node_ptr return_envelope(expression_node_ptr body, results_context_t *rc, bool *&return_invoked)
Definition: exprtk.hpp:27393
bool parse_range(range_t &rp, const bool skip_lsqr=false)
Definition: exprtk.hpp:22600
const T & v1() const
Definition: exprtk.hpp:14380
Definition: exprtk.hpp:4404
expression_node_ptr parse_branch(precedence_level precedence=e_level00)
Definition: exprtk.hpp:25256
node_type & operator=(node_type &)
Definition: exprtk.hpp:14211
Definition: exprtk.hpp:38072
function_N_node(ifunction *func)
Definition: exprtk.hpp:11028
scope_element_manager sem_
Definition: exprtk.hpp:34671
Definition: exprtk.hpp:15955
expression_ptr final_node_
Definition: exprtk.hpp:8974
data_t & ref()
Definition: exprtk.hpp:4698
str_xrox_node(SType0 p0, SType1 p1, RangePack rp0)
Definition: exprtk.hpp:14773
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:32019
file_mode
Definition: exprtk.hpp:36591
vds_t & vds()
Definition: exprtk.hpp:7461
node_type::T0 T0
Definition: exprtk.hpp:30585
Operation operation_t
Definition: exprtk.hpp:14833
static T process(const std::string &t1, const std::string &t2)
Definition: exprtk.hpp:12114
T expm1_impl(const T v, real_type_tag)
Definition: exprtk.hpp:892
element_type type
Definition: exprtk.hpp:18303
ff01_functor f
Definition: exprtk.hpp:16040
expression_node< T >::node_type type() const
Definition: exprtk.hpp:15217
Definition: exprtk.hpp:12129
Definition: exprtk.hpp:4433
irange_t * irange_ptr
Definition: exprtk.hpp:7999
bool side_effect() const
Definition: exprtk.hpp:10311
Definition: exprtk.hpp:5440
parameter_list(std::vector< type_store > &pl)
Definition: exprtk.hpp:4168
expression_node< T > * expression_ptr
Definition: exprtk.hpp:8075
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x(y/z)
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33460
std::size_t cache_size() const
Definition: exprtk.hpp:6937
disabled_entity_set_t disabled_ctrl_set_
Definition: exprtk.hpp:19804
std::string get_vector_name(const vector_holder_ptr &ptr) const
Definition: exprtk.hpp:17396
cocov_t::type1 node_type
Definition: exprtk.hpp:30135
T0 t0_
Definition: exprtk.hpp:13839
void case_normalise(std::string &s)
Definition: exprtk.hpp:166
bool results_available_
Definition: exprtk.hpp:4380
results_context< T > results_context_t
Definition: exprtk.hpp:17792
Definition: exprtk.hpp:14653
Definition: exprtk.hpp:14327
generic_type::scalar_view scalar_t
Definition: exprtk.hpp:37980
node_type::T0 T0
Definition: exprtk.hpp:31862
static details::operator_type operation()
Definition: exprtk.hpp:12116
string_base_node< T > * strbase_ptr_t
Definition: exprtk.hpp:6956
bool is_true_impl(const T v)
Definition: exprtk.hpp:843
static T process_2(const Sequence &arg_list)
Definition: exprtk.hpp:12531
literal_node(const T &v)
Definition: exprtk.hpp:5514
type_store< T > type_store_t
Definition: exprtk.hpp:4272
Definition: exprtk.hpp:4931
Definition: exprtk.hpp:4911
std::string get_variable_name(const expression_ptr &ptr) const
Definition: exprtk.hpp:17391
generic_type::vector_view vector_t
Definition: exprtk.hpp:37108
expression_node_t * expression_node_ptr
Definition: exprtk.hpp:18239
Definition: exprtk.hpp:4438
Definition: exprtk.hpp:14028
node_type::T2 T2
Definition: exprtk.hpp:32484
node_type::T3 T3
Definition: exprtk.hpp:30672
shift_left()
Definition: exprtk.hpp:37534
const control_block::local_data_list_t & local_data_list()
Definition: exprtk.hpp:17886
generic_type::scalar_view scalar_t
Definition: exprtk.hpp:36459
const bool incrementor_deletable_
Definition: exprtk.hpp:6351
expression_node_ptr vararg_function(const details::operator_type &operation, Sequence< expression_node_ptr, Allocator > &arg_list)
Definition: exprtk.hpp:27136
bool is_sf3ext_node(const expression_node< T > *n)
Definition: exprtk.hpp:14118
node_type::T3 T3
Definition: exprtk.hpp:31268
std::list< std::string > local_stringvar_list_
Definition: exprtk.hpp:16651
range_t * range_ptr
Definition: exprtk.hpp:7858
Definition: exprtk.hpp:7568
details::T0oT1oT2< T, T0, T1, T2, typename T0oT1oT2process< T >::mode0 > type0
Definition: exprtk.hpp:14329
const T const_t
Definition: exprtk.hpp:18122
sf3_var_node< T, SpecialFunction > & operator=(sf3_var_node< T, SpecialFunction > &)
void * pointer
Definition: exprtk.hpp:17591
std::map< binary_functor_t, operator_t > inv_binary_op_map_t
Definition: exprtk.hpp:18194
virtual ~generic_function_node()
Definition: exprtk.hpp:11434
Definition: exprtk.hpp:36887
static T process_3(const Sequence &arg_list)
Definition: exprtk.hpp:12397
Definition: exprtk.hpp:32721
std::size_t process(generator &g)
Definition: exprtk.hpp:3082
range_t & range_ref()
Definition: exprtk.hpp:7696
bool to_int(IntType &i) const
Definition: exprtk.hpp:4294
Definition: exprtk.hpp:4429
Definition: exprtk.hpp:4451
std::size_t error_count() const
Definition: exprtk.hpp:20169
std::string value_
Definition: exprtk.hpp:8844
const T & operator[](const std::size_t index) const
Definition: exprtk.hpp:4105
virtual const T & v() const =0
bool result()
Definition: exprtk.hpp:3658
static void execute(T_(&v)[1], const branch_t(&b)[1])
Definition: exprtk.hpp:11150
Definition: exprtk.hpp:4443
node_type::T3 T3
Definition: exprtk.hpp:32615
std::vector< symbol_t > symbol_list_t
Definition: exprtk.hpp:19071
exprtk::details::numeric::details::number_type< T >::type num_type
Definition: exprtk.hpp:36462
expression_node< typename node_type::value_type > * allocate_type(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) const
Definition: exprtk.hpp:15654
write< T > w
Definition: exprtk.hpp:37047
T logn_impl(const T v0, const T v1, int_type_tag)
Definition: exprtk.hpp:959
bool vov_optimisable(const details::operator_type &operation, expression_node_ptr(&branch)[2]) const
Definition: exprtk.hpp:25877
const bool return_deletable_
Definition: exprtk.hpp:6140
generator()
Definition: exprtk.hpp:2194
void * data
Definition: exprtk.hpp:4161
Definition: exprtk.hpp:4442
Definition: exprtk.hpp:36594
expression_ptr branch_
Definition: exprtk.hpp:13439
str_base_ptr str1_base_ptr_
Definition: exprtk.hpp:15070
Definition: exprtk.hpp:12194
const T & v1()
Definition: exprtk.hpp:13356
Definition: exprtk.hpp:4455
std::string error() const
Definition: exprtk.hpp:20159
range_interface< T > irange_t
Definition: exprtk.hpp:7859
expression_ptr loop_body_
Definition: exprtk.hpp:6578
sequence_vector_impl operator=(const sequence_vector_impl &)
Definition: exprtk.hpp:4399
open< T > o
Definition: exprtk.hpp:37045
Definition: exprtk.hpp:18110
branch_t branch_[2]
Definition: exprtk.hpp:5831
bool assignment_disabled(const details::operator_type assignment_operation)
Definition: exprtk.hpp:19514
T value() const
Definition: exprtk.hpp:7206
std::vector< ptr_t > & vec_
Definition: exprtk.hpp:20806
Operation operation_t
Definition: exprtk.hpp:14720
static T process_1(const Sequence &arg_list)
Definition: exprtk.hpp:12591
expression_node< T > * expression_ptr
Definition: exprtk.hpp:7993
T value() const
Definition: exprtk.hpp:5518
~symbol_table()
Definition: exprtk.hpp:16711
Definition: exprtk.hpp:4401
synthesis_node_type_define(const T0 &, const T1 &, e_vov) synthesis_node_type_define(const T0 &
vector_node< T > * vector_node_ptr
Definition: exprtk.hpp:10331
static expression_node< T >::node_type type()
Definition: exprtk.hpp:12115
T nand_impl(const T v0, const T v1, int_type_tag)
Definition: exprtk.hpp:1118
T * vector_base_
Definition: exprtk.hpp:7305
Definition: exprtk.hpp:4407
node_type::T0 T0
Definition: exprtk.hpp:30384
bool unary_optimisable(const details::operator_type &operation) const
Definition: exprtk.hpp:25623
type make_error(const error_mode mode, const lexer::token &tk, const std::string &diagnostic="", const std::string &src_location="")
Definition: exprtk.hpp:18008
details::while_loop_node< T > while_loop_node_t
Definition: exprtk.hpp:18137
node_type::T1 T1
Definition: exprtk.hpp:32613
bipowninv_node(expression_ptr brnch)
Definition: exprtk.hpp:15239
generic_type::vector_view vector_t
Definition: exprtk.hpp:37482
exprtk::parser< Type > parser_t
Definition: exprtk.hpp:25442
T value() const
Definition: exprtk.hpp:9537
Definition: exprtk.hpp:4421
virtual ~ifunction()
Definition: exprtk.hpp:15846
Definition: exprtk.hpp:4441
std::string & s0()
Definition: exprtk.hpp:14868
Definition: exprtk.hpp:4927
expression_node< T >::node_type type() const
Definition: exprtk.hpp:5968
Definition: exprtk.hpp:4144
static T evaluate(const Type x, const Type c11, const Type c10, const Type c9, const Type c8, const Type c7, const Type c6, const Type c5, const Type c4, const Type c3, const Type c2, const Type c1, const Type c0)
Definition: exprtk.hpp:35173
~str_xroxr_node()
Definition: exprtk.hpp:14906
#define unary_opr_switch_statements
Definition: exprtk.hpp:26746
const bool test_deletable_
Definition: exprtk.hpp:6084
Definition: exprtk.hpp:4412
Definition: exprtk.hpp:37239
Definition: exprtk.hpp:29534
PowOp operation_t
Definition: exprtk.hpp:15237
range_pack< T > range_t
Definition: exprtk.hpp:6955
x y * z
Definition: exprtk.hpp:9025
std::size_t & min_num_args()
Definition: exprtk.hpp:15775
vector_holder_t * vector_holder_ptr
Definition: exprtk.hpp:7195
cons_conditional_node(expression_ptr test, expression_ptr consequent)
Definition: exprtk.hpp:6046
Definition: exprtk.hpp:8325
branch_t branch_[1]
Definition: exprtk.hpp:14538
static void print(const std::string &scalar_format, const scalar_t &s)
Definition: exprtk.hpp:36486
node_type::T3 T3
Definition: exprtk.hpp:33458
static bool is_binary(const expression< T > &expr)
Definition: exprtk.hpp:17943
Definition: exprtk.hpp:13389
vovov_t::sf3_type sf3_type
Definition: exprtk.hpp:29477
std::multimap< std::string, details::base_operation_t, details::ilesscompare > base_ops_map_t
Definition: exprtk.hpp:18195
bool register_joiner(lexer::token_joiner *joiner)
Definition: exprtk.hpp:3821
bool is_valid_sf_symbol(const std::string &symbol)
Definition: exprtk.hpp:241
Definition: exprtk.hpp:12204
static T_ execute(ifunction &f, T_(&v)[10])
Definition: exprtk.hpp:11232
const Type ctype
Definition: exprtk.hpp:25444
const generator_t & lexer() const
Definition: exprtk.hpp:3975
bool forward(const std::string &name, const std::size_t &arg_count, symbol_table_t &sym_table, const bool ret_present=false)
Definition: exprtk.hpp:36075
T value() const
Definition: exprtk.hpp:5670
std::string value_
Definition: exprtk.hpp:7983
static const std::string cntrl_struct_list[]
Definition: exprtk.hpp:469
str_base_ptr str_base_ptr_
Definition: exprtk.hpp:8977
expression_node< T >::node_type type() const
Definition: exprtk.hpp:14365
static T process(Type t1, Type t2)
Definition: exprtk.hpp:11996
settings_arithmetic_opr
Definition: exprtk.hpp:19288
branch_t branch_[1]
Definition: exprtk.hpp:14710
static expression_node< T > * allocate(Allocator &allocator, T0 p0, T1 p1, T2 p2, T3 p3, qfunc_t p4)
Definition: exprtk.hpp:14201
bool & b
Definition: exprtk.hpp:20837
switch_node(const Sequence< expression_ptr, Allocator > &arg_list)
Definition: exprtk.hpp:6595
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:37243
vector_holder_ptr vec_node
Definition: exprtk.hpp:18307
Definition: exprtk.hpp:4460
static T process_4(const Sequence &arg_list)
Definition: exprtk.hpp:12775
irange_t * irange_ptr
Definition: exprtk.hpp:8453
std::string value
Definition: exprtk.hpp:2181
bool replacer_enabled() const
Definition: exprtk.hpp:19425
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:29419
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:36948
Definition: exprtk.hpp:5542
Definition: exprtk.hpp:19285
vob_node< T, Operation > & operator=(const vob_node< T, Operation > &)
const T & v0_
Definition: exprtk.hpp:9317
T0oT1< T, T0, T1 > node_type
Definition: exprtk.hpp:13697
covovoc_t::type0 node_type
Definition: exprtk.hpp:31263
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:32617
range_interface< T > irange_t
Definition: exprtk.hpp:7731
Definition: exprtk.hpp:4406
bool init(const std::string &str)
Definition: exprtk.hpp:3956
std::pair< bool, std::size_t > n1_c
Definition: exprtk.hpp:6945
const type_store & front() const
Definition: exprtk.hpp:4197
Definition: exprtk.hpp:2029
std::map< operator_t, unary_functor_t > unary_op_map_t
Definition: exprtk.hpp:18187
Definition: exprtk.hpp:2021
void add_invalid_set1(lexer::token::token_type t)
Definition: exprtk.hpp:3709
expression_node_ptr parse_uninitialised_var_statement(const std::string &var_name)
Definition: exprtk.hpp:24343
static T evaluate(const Type x, const Type c3, const Type c2, const Type c1, const Type c0)
Definition: exprtk.hpp:35269
const Type & vtype
Definition: exprtk.hpp:25443
range_t * range_ptr
Definition: exprtk.hpp:7730
bool is_invalid_break_continue_op(expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:26010
T and_opr(const T v0, const T v1)
Definition: exprtk.hpp:1482
T operator()(std::string &result, parameter_list_t parameters)
Definition: exprtk.hpp:37017
bool enable_numeric_check_
Definition: exprtk.hpp:19791
T value() const
Definition: exprtk.hpp:7671
data_t data()
Definition: exprtk.hpp:4678
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:37430
node_type::T2 T2
Definition: exprtk.hpp:32839
ifunction< T > ifunction_t
Definition: exprtk.hpp:16201
uvouv_node(const T &var0, const T &var1, ufunc_t uf0, ufunc_t uf1, bfunc_t bf)
Definition: exprtk.hpp:13327
const bool initialiser_deletable_
Definition: exprtk.hpp:6579
Definition: exprtk.hpp:13046
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:37244
const bool body_deletable_
Definition: exprtk.hpp:11898
bool is_vararg_function(const std::string &vararg_function_name) const
Definition: exprtk.hpp:17375
expression_node< T >::node_type type() const
Definition: exprtk.hpp:7108
T0 t0() const
Definition: exprtk.hpp:13721
node_type::T1 T1
Definition: exprtk.hpp:31695
bool initialised_
Definition: exprtk.hpp:8840
T0 t0_
Definition: exprtk.hpp:14112
generic_function_node< T, GenericFunction > gen_function_t
Definition: exprtk.hpp:11690
static T_ execute(ifunction &f, T_(&v)[5])
Definition: exprtk.hpp:11267
vds_t vds_
Definition: exprtk.hpp:7235
expression_node< T > * expression_ptr
Definition: exprtk.hpp:5839
settings_store & disable_base_function(settings_base_funcs bf)
Definition: exprtk.hpp:19541
T3 t3() const
Definition: exprtk.hpp:13891
Definition: exprtk.hpp:4913
T logn_impl(const T v0, const T v1, real_type_tag)
Definition: exprtk.hpp:953
expression_node< T >::node_type type() const
Definition: exprtk.hpp:7330
std::string & s1()
Definition: exprtk.hpp:15110
static expression_node< T >::node_type type()
Definition: exprtk.hpp:12160
sort< T > st
Definition: exprtk.hpp:38177
Definition: exprtk.hpp:20748
vovovoc_t::sf4_type sf4_type
Definition: exprtk.hpp:33174
Operation operation_t
Definition: exprtk.hpp:13394
node_type::T2 T2
Definition: exprtk.hpp:30503
range_t range_
Definition: exprtk.hpp:7982
details::T0oT1< T, T0, T1 > type0
Definition: exprtk.hpp:14323
node_type::T1 T1
Definition: exprtk.hpp:33007
const bool condition_deletable_
Definition: exprtk.hpp:6413
Definition: exprtk.hpp:4450
Definition: exprtk.hpp:32308
Definition: exprtk.hpp:4450
Definition: exprtk.hpp:4447
node_type::T3 T3
Definition: exprtk.hpp:32428
details::switch_node< T > switch_node_t
Definition: exprtk.hpp:18145
null_eq_node(expression_ptr brnch, const bool equality=true)
Definition: exprtk.hpp:5462
#define register_binary_op(Op, BinaryFunctor)
Definition: exprtk.hpp:4447
bool is_false(const expression_node< T > *node)
Definition: exprtk.hpp:4991
bool logic_disabled(const std::string &logic_operation)
Definition: exprtk.hpp:19506
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:32093
Definition: exprtk.hpp:2025
Definition: exprtk.hpp:17569
static void execute(std::pair< expression_node< T > *, bool >(&branch)[N])
Definition: exprtk.hpp:5753
vds_t vds_
Definition: exprtk.hpp:10321
void register_local_data(void *data, const std::size_t &size=0, const std::size_t data_mode=0)
Definition: exprtk.hpp:17863
Definition: exprtk.hpp:7069
T value() const
Definition: exprtk.hpp:8502
Definition: exprtk.hpp:16083
Definition: exprtk.hpp:4917
expression_node< T >::node_type type() const
Definition: exprtk.hpp:10142
range_data_type()
Definition: exprtk.hpp:6958
std::string to_str(const details::operator_type &operation) const
Definition: exprtk.hpp:25765
void perform_check()
Definition: exprtk.hpp:36795
bool empty() const
Definition: exprtk.hpp:18559
Definition: exprtk.hpp:4932
expression_node_ptr const_optimise_sf3(const details::operator_type &operation, expression_node_ptr(&branch)[3])
Definition: exprtk.hpp:26836
expression_node< T > * expression_ptr
Definition: exprtk.hpp:9485
T(* tfunc_t)(Type t0, Type t1, Type t2)
Definition: exprtk.hpp:2004
covovov_t::sf4_type sf4_type
Definition: exprtk.hpp:32367
virtual ~expression_node()
Definition: exprtk.hpp:4941
Definition: exprtk.hpp:4396
type_view< T > vector_view
Definition: exprtk.hpp:4267
details::rebasevector_elem_node< T > rebasevector_elem_node_t
Definition: exprtk.hpp:18148
Definition: exprtk.hpp:33395
bool is_invalid_string_op(const details::operator_type &operation, expression_node_ptr(&branch)[3])
Definition: exprtk.hpp:26040
static const std::size_t arithmetic_ops_list_size
Definition: exprtk.hpp:481
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:32768
bool valid_vararg_operation(const std::string &symbol)
Definition: exprtk.hpp:20236
expression_node_ptr synthesize_expression(const details::operator_type &operation, expression_node_ptr(&branch)[N])
Definition: exprtk.hpp:34284
Definition: exprtk.hpp:13148
vec_data_store< T > vds_t
Definition: exprtk.hpp:7135
static const double sqrt2
Definition: exprtk.hpp:747
Definition: exprtk.hpp:4421
node_type::T0 T0
Definition: exprtk.hpp:32612
for_loop_bc_node(expression_ptr initialiser, expression_ptr condition, expression_ptr incrementor, expression_ptr loop_body)
Definition: exprtk.hpp:6486
node_type::T3 T3
Definition: exprtk.hpp:31645
T xor_impl(const T v0, const T v1, int_type_tag)
Definition: exprtk.hpp:1154
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:37977
details::string_literal_node< T > string_literal_node_t
Definition: exprtk.hpp:18154
irange_ptr str0_range_ptr_
Definition: exprtk.hpp:8842
Definition: exprtk.hpp:12721
static T_ execute(ifunction &f, T_(&v)[4])
Definition: exprtk.hpp:11274
usr_mode
Definition: exprtk.hpp:19007
vec_data_store< T > vds_t
Definition: exprtk.hpp:10672
Definition: exprtk.hpp:18225
~vob_node()
Definition: exprtk.hpp:14507
std::map< std::string, base_func * > funcparam_t
Definition: exprtk.hpp:35707
static control_block * create(const std::size_t &dsize, data_t data_ptr=data_t(0), bool dstrct=false)
Definition: exprtk.hpp:4584
expression_node_ptr string_function_call(igeneric_function_t *gf, std::vector< expression_node_ptr > &arg_list, const std::size_t ¶m_seq_index=std::numeric_limits< std::size_t >::max())
Definition: exprtk.hpp:27308
Definition: exprtk.hpp:4415
bool initialised_
Definition: exprtk.hpp:8976
T shl_impl(const T v0, const T v1, int_type_tag)
Definition: exprtk.hpp:1078
timer()
Definition: exprtk.hpp:36376
Definition: exprtk.hpp:31802
Definition: exprtk.hpp:35737
std::string entity_name(const PtrType &ptr) const
Definition: exprtk.hpp:16236
static T evaluate(const Type x, const Type c10, const Type c9, const Type c8, const Type c7, const Type c6, const Type c5, const Type c4, const Type c3, const Type c2, const Type c1, const Type c0)
Definition: exprtk.hpp:35186
settings_base_funcs
Definition: exprtk.hpp:19249
Definition: exprtk.hpp:11783
vector_assignment_node(T *vector_base, const std::size_t &size, const std::vector< expression_ptr > &initialiser_list, const bool single_value_initialse)
Definition: exprtk.hpp:7245
Definition: exprtk.hpp:4431
static T result(T v)
Definition: exprtk.hpp:1561
#define exprtk_define_freefunction(NN)
Definition: exprtk.hpp:17057
T value() const
Definition: exprtk.hpp:15090
Definition: exprtk.hpp:4396
node_type::T3 T3
Definition: exprtk.hpp:31457
vector_interface< T > * ivector_ptr
Definition: exprtk.hpp:13048
Definition: exprtk.hpp:23129
virtual ~sos_base_node()
Definition: exprtk.hpp:13230
Definition: exprtk.hpp:4403
Definition: exprtk.hpp:4435
generic_type::string_view string_t
Definition: exprtk.hpp:36894
expression_node< T >::node_type type() const
Definition: exprtk.hpp:6075
string_base_node< T > * str_base_ptr
Definition: exprtk.hpp:7995
bool is_negate_node(const expression_node< T > *node)
Definition: exprtk.hpp:5125
T and_impl(const T v0, const T v1, int_type_tag)
Definition: exprtk.hpp:1106
symbol_table< T > & operator=(const symbol_table< T > &st)
Definition: exprtk.hpp:16722
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:32036
Definition: exprtk.hpp:13445
expression_node< T >::node_type type() const
Definition: exprtk.hpp:8244
expression_node< T > * expression_ptr
Definition: exprtk.hpp:14657
expression_ptr branch_
Definition: exprtk.hpp:8307
node_type::T3 T3
Definition: exprtk.hpp:32091
Definition: exprtk.hpp:33284
expression_generator< T > expression_generator_
Definition: exprtk.hpp:34653
virtual ~voc_base_node()
Definition: exprtk.hpp:13134
const T & v_
Definition: exprtk.hpp:14587
Definition: exprtk.hpp:37001
vector_holder_t * vector_holder_ptr
Definition: exprtk.hpp:16882
expression_node< T >::node_type type() const
Definition: exprtk.hpp:15095
exprtk::expression< T > expression_t
Definition: exprtk.hpp:35395
settings_store & enable_base_function(settings_base_funcs bf)
Definition: exprtk.hpp:19619
Definition: exprtk.hpp:4908
T neg_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1297
Definition: exprtk.hpp:4400
settings_store & disable_control_structure(settings_control_structs ctrl_struct)
Definition: exprtk.hpp:19554
Definition: exprtk.hpp:4930
static void destroy(control_block *&cntrl_blck)
Definition: exprtk.hpp:17659
expression_node< T >::node_type type() const
Definition: exprtk.hpp:5929
Operation operation_t
Definition: exprtk.hpp:14896
details::functor_t< T > functor_t
Definition: exprtk.hpp:13463
generic_function_ptr get_generic_function(const std::string &function_name) const
Definition: exprtk.hpp:18703
Operation operation_t
Definition: exprtk.hpp:14352
void print_type(const std::string &fmt, const T v, exprtk::details::numeric::details::real_type_tag)
Definition: exprtk.hpp:36447
Definition: exprtk.hpp:32534
expression_node< T > * expression_ptr
Definition: exprtk.hpp:9260
static T process(const Sequence< Type, Allocator > &arg_list)
Definition: exprtk.hpp:12303
Definition: exprtk.hpp:5456
Definition: exprtk.hpp:9940
expression_node< T > * branch(const std::size_t &) const
Definition: exprtk.hpp:14577
T value() const
Definition: exprtk.hpp:7093
void scan_special_function()
Definition: exprtk.hpp:2699
Definition: exprtk.hpp:4431
Definition: exprtk.hpp:2013
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:31981
details::cons_conditional_str_node< T > cons_conditional_str_node_t
Definition: exprtk.hpp:18162
Definition: exprtk.hpp:4397
expression_node< T >::node_type type() const
Definition: exprtk.hpp:15187
T value() const
Definition: exprtk.hpp:5963
const T & type
Definition: exprtk.hpp:35495
Definition: exprtk.hpp:4903
T nand_impl(const T v0, const T v1, real_type_tag)
Definition: exprtk.hpp:1112
std::string to_str(const StringView &view)
Definition: exprtk.hpp:4322
node_type::T3 T3
Definition: exprtk.hpp:32896
const T & cref_t
Definition: exprtk.hpp:18121
polynomial()
Definition: exprtk.hpp:35300
void update(const T &v0, const T &v1, const T &v2, const T &v3, const T &v4)
Definition: exprtk.hpp:35537
virtual bool process(const std::string &, symbol_table_t &, std::string &)
Definition: exprtk.hpp:19037
static const double pi_180
Definition: exprtk.hpp:742
std::pair< std::size_t, std::size_t > cached_range_t
Definition: exprtk.hpp:6828
Definition: exprtk.hpp:4400
static const expression_node< T >::node_type result
Definition: exprtk.hpp:13639
static bool process(parameter_list_t ¶meters, std::size_t &r0, std::size_t &r1, const std::size_t &r0_prmidx, const std::size_t &r1_prmidx, const std::size_t vec_idx=0)
Definition: exprtk.hpp:37110
#define igeneric_function_empty_body(N)
Definition: exprtk.hpp:15970
Definition: exprtk.hpp:12561
range_ptr str0_range_ptr_
Definition: exprtk.hpp:8219
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:30590
static T process(Type t1, Type t2)
Definition: exprtk.hpp:12103
Definition: exprtk.hpp:18508
std::size_t size() const
Definition: exprtk.hpp:7608
static T process(const T &, const T &)
Definition: exprtk.hpp:12197
T log1p_impl(const T v, real_type_tag)
Definition: exprtk.hpp:965
igfun_t::generic_type generic_type
Definition: exprtk.hpp:37791
details::conditional_string_node< T > conditional_string_node_t
Definition: exprtk.hpp:18161
Definition: exprtk.hpp:4415
range_t range() const
Definition: exprtk.hpp:7691
Definition: exprtk.hpp:4899
assignment_vec_elem_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:9525
static T process(const arg_list_t &arg)
Definition: exprtk.hpp:26676
static details::operator_type operation()
Definition: exprtk.hpp:12170
vovovov_t::sf4_type sf4_type
Definition: exprtk.hpp:33118
bool return_present_
Definition: exprtk.hpp:19213
Definition: exprtk.hpp:4926
void copy(const dependency_graph::Selection &selection)
Definition: actions.cpp:194
Definition: exprtk.hpp:5319
void init(possumwood::Metadata &meta)
Definition: asf.cpp:417
operator_type operation_
Definition: exprtk.hpp:5699
bool remove_vector(const std::string &vector_name)
Definition: exprtk.hpp:17217
Definition: exprtk.hpp:4448
Definition: exprtk.hpp:14336
~scoped_bool_negator()
Definition: exprtk.hpp:20819
Definition: exprtk.hpp:4430
getline< T > g
Definition: exprtk.hpp:37049
Definition: exprtk.hpp:37285
bool run_joiners(lexer::generator &g)
Definition: exprtk.hpp:3871
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:37104
bool strength_reduction_enabled_
Definition: exprtk.hpp:34360
bool equality_
Definition: exprtk.hpp:5506
branch_t branch_[1]
Definition: exprtk.hpp:15197
vocov_t::sf3_type sf3_type
Definition: exprtk.hpp:29718
expression_node< T > * expression_ptr
Definition: exprtk.hpp:11849
T2 t2() const
Definition: exprtk.hpp:14084
static T process(Type t1, Type t2)
Definition: exprtk.hpp:12150
igfun_t::generic_type generic_type
Definition: exprtk.hpp:37382
expression_node_ptr const_optimise_mswitch(Sequence< expression_node_ptr, Allocator > &arg_list)
Definition: exprtk.hpp:26567
static void execute(T_(&v)[4], const branch_t(&b)[4])
Definition: exprtk.hpp:11117
Definition: exprtk.hpp:4413
Definition: exprtk.hpp:4926
virtual ~ivariable()
Definition: exprtk.hpp:6768
for_loop_node(expression_ptr initialiser, expression_ptr condition, expression_ptr incrementor, expression_ptr loop_body)
Definition: exprtk.hpp:6275
T value() const
Definition: exprtk.hpp:13409
virtual range_t & range_ref()=0
Definition: exprtk.hpp:2027
bool operation_optimisable(const details::operator_type &operation) const
Definition: exprtk.hpp:25791
T value() const
Definition: exprtk.hpp:8287
node_type::T2 T2
Definition: exprtk.hpp:32034
bool uvouv_optimisable(const details::operator_type &operation, expression_node_ptr(&branch)[2]) const
Definition: exprtk.hpp:25936
vector_node_ptr vec1_node_ptr_
Definition: exprtk.hpp:10812
Definition: exprtk.hpp:18114
cons_conditional_str_node(expression_ptr test, expression_ptr consequent)
Definition: exprtk.hpp:8747
unknown_type_tag()
Definition: exprtk.hpp:752
const T & v() const
Definition: exprtk.hpp:14475
expression_node_ptr while_loop(expression_node_ptr &condition, expression_node_ptr &branch, const bool brkcont=false) const
Definition: exprtk.hpp:26404
const bfunc_t f0_
Definition: exprtk.hpp:13842
const T1 const T2 const T3
Definition: exprtk.hpp:13672
T pos_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1298
const value_t * end() const
Definition: exprtk.hpp:4253
std::string file_name
Definition: exprtk.hpp:36609
Operation operation_t
Definition: exprtk.hpp:14598
expression_node< typename node_type::value_type > * allocate_c(const T1 &t1) const
Definition: exprtk.hpp:15468
binary_op_map_t binary_op_map_
Definition: exprtk.hpp:34666
const bool loop_body_deletable_
Definition: exprtk.hpp:6212
expression_node< T > * expression_ptr
Definition: exprtk.hpp:5945
std::size_t get_stringvar_list(Sequence< std::pair< std::string, std::string >, Allocator > &svlist) const
Definition: exprtk.hpp:17280
Definition: exprtk.hpp:4399
T value_type
Definition: exprtk.hpp:14049
static details::operator_type operation()
Definition: exprtk.hpp:12076
range_pack< T > range_t
Definition: exprtk.hpp:7488
expression_node< T > * expression_ptr
Definition: exprtk.hpp:14596
generic_type::scalar_view scalar_t
Definition: exprtk.hpp:38079
Definition: exprtk.hpp:4439
ViewType value_t
Definition: exprtk.hpp:4223
Definition: exprtk.hpp:16184
any_false< T > nf
Definition: exprtk.hpp:38170
~scoped_bft()
Definition: exprtk.hpp:35727
virtual ~string_range_node()
Definition: exprtk.hpp:7583
details::vector_holder< T > vector_holder_t
Definition: exprtk.hpp:16583
T value() const
Definition: exprtk.hpp:14673
range_interface< T > irange_t
Definition: exprtk.hpp:8336
void * stream_ptr
Definition: exprtk.hpp:36607
void * data
Definition: exprtk.hpp:18305
const vds_t & vds() const
Definition: exprtk.hpp:7052
node_type::T2 T2
Definition: exprtk.hpp:33401
Definition: exprtk.hpp:36533
settings_store & enable_control_structure(settings_control_structs ctrl_struct)
Definition: exprtk.hpp:19637
stringvar_t * stringvar_ptr
Definition: exprtk.hpp:16587
std::string name_
Definition: exprtk.hpp:35486
static const std::size_t logic_ops_list_size
Definition: exprtk.hpp:467
details::rebasevector_celem_node< T > rebasevector_celem_node_t
Definition: exprtk.hpp:18149
node_type::T1 T1
Definition: exprtk.hpp:30670
swap_node(variable_node_ptr var0, variable_node_ptr var1)
Definition: exprtk.hpp:7319
T logn(const T v0, const T v1)
Definition: exprtk.hpp:1433
Definition: exprtk.hpp:4443
Definition: exprtk.hpp:4912
bool state_
Definition: exprtk.hpp:3485
Definition: exprtk.hpp:4899
Definition: exprtk.hpp:1992
std::string error_line
Definition: exprtk.hpp:17990
bool valid(const std::string &name, const std::size_t &arg_count) const
Definition: exprtk.hpp:36062
std::map< operator_t, binary_functor_t > binary_op_map_t
Definition: exprtk.hpp:18188
Definition: exprtk.hpp:37426
bool final_deletable_
Definition: exprtk.hpp:8975
node_type::T3 T3
Definition: exprtk.hpp:33515
expression_ptr consequent_
Definition: exprtk.hpp:6083
Definition: exprtk.hpp:4424
type_view(type_store_t &ts)
Definition: exprtk.hpp:4225
T value() const
Definition: exprtk.hpp:7910
expression_node< T >::node_type type() const
Definition: exprtk.hpp:6132
bool logic_enabled(const std::string &logic_operation)
Definition: exprtk.hpp:19455
void remove_last_error()
Definition: exprtk.hpp:34376
T1_ T1
Definition: exprtk.hpp:13855
bool collect_variables_enabled() const
Definition: exprtk.hpp:19432
bool valid_symbol(const std::string &symbol, const bool check_reserved_symb=true) const
Definition: exprtk.hpp:17484
T2 t2_
Definition: exprtk.hpp:14215
generic_type::vector_view vector_t
Definition: exprtk.hpp:37883
static const std::size_t base_function_list_size
Definition: exprtk.hpp:460
void lodge_assignment(symbol_type cst, expression_node_ptr node)
Definition: exprtk.hpp:27511
std::string str() const
Definition: exprtk.hpp:11653
Definition: exprtk.hpp:36599
bool invalid_bracket_check(lexer::token::token_type base, lexer::token::token_type t)
Definition: exprtk.hpp:3728
bool return_stmt_present
Definition: exprtk.hpp:18990
Definition: exprtk.hpp:36595
Definition: exprtk.hpp:4919
Definition: exprtk.hpp:4459
details::functor_t< T > functor_t
Definition: exprtk.hpp:13323
Definition: exprtk.hpp:4435
Definition: exprtk.hpp:33115
bool arithmetic_disabled(const details::operator_type arithmetic_operation)
Definition: exprtk.hpp:19523
Definition: exprtk.hpp:4916
Definition: exprtk.hpp:13254
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:29479
scalar_view(const type_store_t &ts)
Definition: exprtk.hpp:4279
node_type::T1 T1
Definition: exprtk.hpp:32145
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:37879
bool is_error() const
Definition: exprtk.hpp:2169
bool is_t0ot1ot2_node(const expression_node< T > *node)
Definition: exprtk.hpp:15298
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33293
numeric_checker()
Definition: exprtk.hpp:3496
expression_node< typename node_type::value_type > * allocate(T1 &t1) const
Definition: exprtk.hpp:15462
Definition: exprtk.hpp:30368
Definition: exprtk.hpp:19275
void restore()
Definition: exprtk.hpp:2253
freefunc05(ff05_functor ff)
Definition: exprtk.hpp:16077
const T & v_
Definition: exprtk.hpp:15160
void copy(const var_t &src_v, varref_t &dest_v)
Definition: exprtk.hpp:35639
Definition: exprtk.hpp:12050
virtual ~base_func()
Definition: exprtk.hpp:35512
T2 t2() const
Definition: exprtk.hpp:14175
eof()
Definition: exprtk.hpp:37030
details::scor_node< T > scor_node_t
Definition: exprtk.hpp:18171
vector_node_ptr vec()
Definition: exprtk.hpp:10137
static const std::size_t cntrl_struct_list_size
Definition: exprtk.hpp:474
static T_ execute(ifunction &f, T_(&v)[1])
Definition: exprtk.hpp:11295
expression_node< T > * expression_ptr
Definition: exprtk.hpp:11024
type_store< ifunction< T >, ifunction< T > > function_store
Definition: exprtk.hpp:16607
operator_type operation() const
Definition: exprtk.hpp:13711
Definition: exprtk.hpp:4922
expression_node_ptr parse_expression(precedence_level precedence=e_level00)
Definition: exprtk.hpp:20409
virtual ~vector_interface()
Definition: exprtk.hpp:6983
expression_node< T > * branch(const std::size_t &index=0) const
Definition: exprtk.hpp:5870
const bool condition_deletable_
Definition: exprtk.hpp:6580
expression_t compile(const std::string &expression_string, symbol_table_t &symtab)
Definition: exprtk.hpp:20012
Definition: exprtk.hpp:4909
covocov_t::type1 node_type
Definition: exprtk.hpp:31917
settings_store & enable_all_control_structures()
Definition: exprtk.hpp:19329
type_ptr get_from_varptr(const void *ptr) const
Definition: exprtk.hpp:16435
virtual bool init_branches()
Definition: exprtk.hpp:11439
irange_t * irange_ptr
Definition: exprtk.hpp:8337
vovocov_t::type2 node_type
Definition: exprtk.hpp:32254
file_mode get_file_mode(const std::string &access)
Definition: exprtk.hpp:36752
bool add_vector(const std::string &vector_name, T *v, const std::size_t &v_size)
Definition: exprtk.hpp:17140
T0 t0() const
Definition: exprtk.hpp:13978
T0oT1< T, T0, T1 > & operator=(T0oT1< T, T0, T1 > &)
Definition: exprtk.hpp:13749
static T process(Type t1, Type t2)
Definition: exprtk.hpp:12113
Definition: exprtk.hpp:8318
expression_node_ptr synthesize_srocsr_expression(const details::operator_type &opr, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33850
Definition: exprtk.hpp:4914
std::string branch_to_id(expression_node_ptr branch)
Definition: exprtk.hpp:25813
details::T0oT1oT2_define< T, cref_t, const_t, cref_t > vocov_t
Definition: exprtk.hpp:18204
Definition: exprtk.hpp:4915
static T process(Type t1, Type t2)
Definition: exprtk.hpp:12063
void create_data()
Definition: exprtk.hpp:4623
Definition: exprtk.hpp:4427
std::string remaining() const
Definition: exprtk.hpp:2321
settings_store & enable_logic_operation(settings_logic_opr logic)
Definition: exprtk.hpp:19655
const vds_t & vds() const
Definition: exprtk.hpp:9888
static const double e
Definition: exprtk.hpp:738
expression_node_ptr synthesize_vecarithmetic_operation_expression(const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:27832
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:36961
static const expression_node< T >::node_type result
Definition: exprtk.hpp:13617
void clear_stack()
Definition: exprtk.hpp:35685
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:30740
static bool compile(expression_generator< Type > &expr_gen, const std::string &id, T0 t0, T1 t1, T2 t2, T3 t3, expression_node_ptr &result)
Definition: exprtk.hpp:29269
Definition: exprtk.hpp:4911
vector_node_ptr temp_vec_node_
Definition: exprtk.hpp:10503
bool is_digit(const char_t c)
Definition: exprtk.hpp:122
expression_ptr expr
Definition: exprtk.hpp:17676
virtual ~vov_base_node()
Definition: exprtk.hpp:13098
str_xoxr_node< T, SType0, SType1, RangePack, Operation > & operator=(str_xoxr_node< T, SType0, SType1, RangePack, Operation > &)
Definition: exprtk.hpp:19254
node_type::T2 T2
Definition: exprtk.hpp:32783
T max(const T v0, const T v1)
Definition: exprtk.hpp:1398
expression_node< T >::node_type type() const
Definition: exprtk.hpp:14058
T value() const
Definition: exprtk.hpp:10870
vocovoc_t::type4 node_type
Definition: exprtk.hpp:33453
void clear()
Definition: exprtk.hpp:18279
Definition: exprtk.hpp:4422
vovoc_t::type1 node_type
Definition: exprtk.hpp:29597
Definition: exprtk.hpp:4405
Definition: exprtk.hpp:4923
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:32261
Definition: exprtk.hpp:4899
void init_precompilation()
Definition: exprtk.hpp:19853
virtual int insert(const token &, token &) token_inserter_empty_body inline virtual int insert(const token &
bool is_whitespace(const char_t c)
Definition: exprtk.hpp:93
bool function_enabled(const std::string &function_name)
Definition: exprtk.hpp:19439
node_type::T0 T0
Definition: exprtk.hpp:33399
std::size_t size() const
Definition: exprtk.hpp:7528
Definition: exprtk.hpp:6684
node_type::T0 T0
Definition: exprtk.hpp:32256
static T_ execute(ifunction &f, T_(&v)[14])
Definition: exprtk.hpp:11204
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:32373
T value() const
Definition: exprtk.hpp:13336
bool run_inserters(lexer::generator &g)
Definition: exprtk.hpp:3893
generic_type::vector_view vector_t
Definition: exprtk.hpp:37530
expression_node< T >::node_type type() const
Definition: exprtk.hpp:7037
Definition: exprtk.hpp:13550
Definition: exprtk.hpp:13504
void destroy_node(expression_node< T > *&node)
Definition: exprtk.hpp:5236
ror< T > rr
Definition: exprtk.hpp:38174
freefunc04(ff04_functor ff)
Definition: exprtk.hpp:16067
details::variable_node< T > variable_node_t
Definition: exprtk.hpp:16200
bool enable_bracket_check_
Definition: exprtk.hpp:19792
SType0 s0_
Definition: exprtk.hpp:14955
expression_node_ptr synthesize_csrocs_expression(const details::operator_type &opr, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33940
T tan_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1302
Definition: exprtk.hpp:33002
Definition: exprtk.hpp:4395
parser_t & parser_
Definition: exprtk.hpp:18542
Definition: exprtk.hpp:19307
stringvar_size_node()
Definition: exprtk.hpp:8231
Definition: exprtk.hpp:197
Definition: exprtk.hpp:4910
virtual void set_c(const T)=0
static expression_node< T >::node_type type()
Definition: exprtk.hpp:12212
settings_store & settings()
Definition: exprtk.hpp:20146
expression_node< typename node_type::value_type > * allocate(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5) const
Definition: exprtk.hpp:15563
T value() const
Definition: exprtk.hpp:13287
static std::string to_str(token_type t)
Definition: exprtk.hpp:2122
Definition: exprtk.hpp:4904
T value() const
Definition: exprtk.hpp:9575
expression_node_ptr parse_symbol()
Definition: exprtk.hpp:25148
igeneric_function< T > igeneric_function_t
Definition: exprtk.hpp:18128
~str_vararg_node()
Definition: exprtk.hpp:8914
Definition: exprtk.hpp:12147
bool voc_optimisable(const details::operator_type &operation, expression_node_ptr(&branch)[2]) const
Definition: exprtk.hpp:25868
Definition: exprtk.hpp:2017
bool remove_variable(const std::string &variable_name, const bool delete_node=true)
Definition: exprtk.hpp:17183
static std::string id()
Definition: exprtk.hpp:13916
~binary_node()
Definition: exprtk.hpp:5795
Definition: exprtk.hpp:4931
std::size_t size() const
Definition: exprtk.hpp:18326
~st_data()
Definition: exprtk.hpp:16626
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:37598
expression_node< T > * expression_ptr
Definition: exprtk.hpp:6688
const bool consequent_deletable_
Definition: exprtk.hpp:6085
operator_type operation() const
Definition: exprtk.hpp:5682
Definition: exprtk.hpp:4460
node_type::T0 T0
Definition: exprtk.hpp:32144
str_vararg_node(const Sequence< expression_ptr, Allocator > &arg_list)
Definition: exprtk.hpp:8866
const T & ref() const
Definition: exprtk.hpp:7103
details::expression_node< T > * expression_ptr
Definition: exprtk.hpp:17561
collect_type
Definition: exprtk.hpp:19045
sf4_var_node< T, SpecialFunction > & operator=(sf4_var_node< T, SpecialFunction > &)
#define empty_method_body
Definition: exprtk.hpp:15849
node_type::T0 T0
Definition: exprtk.hpp:33512
static expression_node< T >::node_type type()
Definition: exprtk.hpp:12075
Definition: exprtk.hpp:4906
Definition: exprtk.hpp:14967
static void process(std::pair< expression_node< T > *, bool >(&)[N], expression_node< T > *)
Definition: exprtk.hpp:5708
char_cptr base() const
Definition: exprtk.hpp:8813
~control_block()
Definition: exprtk.hpp:17615
symbol_table_t::stringvar_ptr stringvar_ptr
Definition: exprtk.hpp:18553
static T process(const std::string &t1, const std::string &t2)
Definition: exprtk.hpp:12198
expression_node< T > * expression_ptr
Definition: exprtk.hpp:9523
std::deque< var_t > local_stack
Definition: exprtk.hpp:35704
assignment_rebasevec_celem_op_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:10020
void lodge_symbol(const std::string &symbol, const symbol_type st)
Definition: exprtk.hpp:22775
voc_node< T, Operation > & operator=(const voc_node< T, Operation > &)
expression_node< T > * branch(const std::size_t &) const
Definition: exprtk.hpp:14632
generic_type::vector_view vector_t
Definition: exprtk.hpp:37981
irange_t * irange_ptr
Definition: exprtk.hpp:8586
T tanh_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1303
symbol_table< T > symbol_table_t
Definition: exprtk.hpp:18175
bool return_invoked() const
Definition: exprtk.hpp:17805
const std::string & ref() const
Definition: exprtk.hpp:7538
settings_store & enable_arithmetic_operation(settings_arithmetic_opr arithmetic)
Definition: exprtk.hpp:19673
Definition: exprtk.hpp:13690
T value() const
Definition: exprtk.hpp:7510
str_base_ptr str1_base_ptr_
Definition: exprtk.hpp:8435
T sin_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1299
char_cptr base() const
Definition: exprtk.hpp:7950
details::functor_t< T > functor_t
Definition: exprtk.hpp:13506
bool register_package(exprtk::symbol_table< T > &symtab)
Definition: exprtk.hpp:38189
vector_node< T > * vec0_node_ptr_
Definition: exprtk.hpp:9895
ff14_functor f
Definition: exprtk.hpp:16181
Definition: exprtk.hpp:30497
data_pack(void *ptr, const data_type dt, const std::size_t sz=0)
Definition: exprtk.hpp:17585
const bool consequent_deletable_
Definition: exprtk.hpp:6034
sequence_validator()
Definition: exprtk.hpp:3631
irange_t * irange_ptr
Definition: exprtk.hpp:8862
std::size_t size() const
Definition: exprtk.hpp:10483
bool is_letter(const char_t c)
Definition: exprtk.hpp:116
bool is_invalid_arithmetic_operation(const details::operator_type operation)
Definition: exprtk.hpp:20263
~for_loop_node()
Definition: exprtk.hpp:6289
expression_node< typename node_type::value_type > * allocate(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4) const
Definition: exprtk.hpp:15554
node_type::T2 T2
Definition: exprtk.hpp:31752
static T process_4(const Sequence &arg_list)
Definition: exprtk.hpp:12403
details::T0oT1oT2oT3_define< T, const_t, cref_t, cref_t, const_t > covovoc_t
Definition: exprtk.hpp:18218
details(const std::size_t &vsize, const unsigned int loop_batch_size=global_loop_batch_size)
Definition: exprtk.hpp:4512
Definition: exprtk.hpp:4415
char_cptr base() const
Definition: exprtk.hpp:8947
bool create_stringvar(const std::string &stringvar_name, const std::string &value=std::string(""))
Definition: exprtk.hpp:16958
operator_type
Definition: exprtk.hpp:4391
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:31849
covov_t::sf3_type sf3_type
Definition: exprtk.hpp:29778
std::vector< lvarref_t > lvr_vec_t
Definition: exprtk.hpp:35500
node_type::T0 T0
Definition: exprtk.hpp:32781
generic_type::vector_view vector_t
Definition: exprtk.hpp:37384
value_t * data_
Definition: exprtk.hpp:4264
vds_t & vds()
Definition: exprtk.hpp:9733
range_t & range_ref()
Definition: exprtk.hpp:7960
local_data_t & local_data()
Definition: exprtk.hpp:17538
opr_base< T >::Type Type
Definition: exprtk.hpp:12206
T value() const
Definition: exprtk.hpp:9411
node_type::T1 T1
Definition: exprtk.hpp:32782
bool is_string_ccondition_node(const expression_node< T > *node)
Definition: exprtk.hpp:15364
freefunc13(ff13_functor ff)
Definition: exprtk.hpp:16164
functor_t::tfunc_t tfunc_t
Definition: exprtk.hpp:14226
T value
Definition: exprtk.hpp:6098
std::size_t position
Definition: exprtk.hpp:2182
static T evaluate(const Type x, const Type c4, const Type c3, const Type c2, const Type c1, const Type c0)
Definition: exprtk.hpp:35259
expression_node_ptr parse_special_function()
Definition: exprtk.hpp:23611
type_store & back()
Definition: exprtk.hpp:4202
vov_node(const T &var0, const T &var1)
Definition: exprtk.hpp:14355
details::expression_node< T > * expression_ptr
Definition: exprtk.hpp:16199
Definition: exprtk.hpp:4900
bool symbol_exists(const std::string &symbol_name) const
Definition: exprtk.hpp:16225
Definition: exprtk.hpp:4403
void restore_token()
Definition: exprtk.hpp:3986
Definition: exprtk.hpp:13226
std::size_t size
Definition: exprtk.hpp:4160
Definition: exprtk.hpp:16313
Definition: exprtk.hpp:23545
count< T > c
Definition: exprtk.hpp:38171
settings_logic_opr
Definition: exprtk.hpp:19280
Definition: exprtk.hpp:19264
const bool branch_deletable_
Definition: exprtk.hpp:7840
branch_t branch_[N]
Definition: exprtk.hpp:11308
bool is_right_bracket(const char_t c)
Definition: exprtk.hpp:137
T3 t3_
Definition: exprtk.hpp:13939
bool is_reserved_word(const std::string &symbol)
Definition: exprtk.hpp:500
static T process_1(const Sequence &arg_list)
Definition: exprtk.hpp:12525
std::size_t size() const
Definition: exprtk.hpp:8043
operator_type operation()
Definition: exprtk.hpp:5865
node_type::T1 T1
Definition: exprtk.hpp:32838
str_base_ptr str0_base_ptr_
Definition: exprtk.hpp:15069
T xnor_impl(const T v0, const T v1, real_type_tag)
Definition: exprtk.hpp:1160
covovov_t::type2 node_type
Definition: exprtk.hpp:32366
tmp_vs_t expr_as_vec1_store_
Definition: exprtk.hpp:11595
bool finished() const
Definition: exprtk.hpp:2294
bool enable_joiner_
Definition: exprtk.hpp:19790
T integrate(const expression< T > &e, T &x, const T &r0, const T &r1, const std::size_t number_of_intervals=1000000)
Definition: exprtk.hpp:34836
scoped_delete(parser< T > &pr, ptr_t(&p)[N])
Definition: exprtk.hpp:20721
static details::operator_type operation()
Definition: exprtk.hpp:12190
Definition: exprtk.hpp:35765
static T process(const std::string &t1, const std::string &t2)
Definition: exprtk.hpp:12188
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:32880
node_type::T2 T2
Definition: exprtk.hpp:32427
control_block()
Definition: exprtk.hpp:16656
PowOp operation_t
Definition: exprtk.hpp:15139
Definition: exprtk.hpp:4424
void set_expression(const expression_ptr expr)
Definition: exprtk.hpp:17817
Definition: exprtk.hpp:29835
range_interface< T > irange_t
Definition: exprtk.hpp:8744
virtual T value() const
Definition: exprtk.hpp:4944
igeneric_function< T > igeneric_function_t
Definition: exprtk.hpp:16203
bool collect_functions_enabled() const
Definition: exprtk.hpp:19433
sumk< T > sk
Definition: exprtk.hpp:38180
int insert(const lexer::token &t0, const lexer::token &t1, lexer::token &new_token)
Definition: exprtk.hpp:3186
std::pair< void *, std::size_t > void_t
Definition: exprtk.hpp:11423
bool is_letter_or_digit(const char_t c)
Definition: exprtk.hpp:127
static expression_node_ptr process(parser< Type > &p, const details::operator_type opt_type, const std::string &sf_name)
Definition: exprtk.hpp:23547
std::size_t size() const
Definition: exprtk.hpp:5262
variable_node< T > variable_node_t
Definition: exprtk.hpp:11415
node_type::T1 T1
Definition: exprtk.hpp:32369
bool add_replace(const std::string &target_symbol, const std::string &replace_symbol, const lexer::token::token_type token_type=lexer::token::e_symbol)
Definition: exprtk.hpp:3573
ivararg_function< T > ivararg_function_t
Definition: exprtk.hpp:16202
expression_node< T > * expression_ptr
Definition: exprtk.hpp:6044
type_store()
Definition: exprtk.hpp:4154
covovoc_t::sf4_type sf4_type
Definition: exprtk.hpp:31264
token_type type
Definition: exprtk.hpp:2180
node_type::T3 T3
Definition: exprtk.hpp:33346
const vds_t & vds() const
Definition: exprtk.hpp:10157
Definition: exprtk.hpp:15997
type_store_t & ts_
Definition: exprtk.hpp:4263
virtual ~string_base_node()
Definition: exprtk.hpp:5570
value_ptr data() const
Definition: exprtk.hpp:5418
virtual ~null_igenfunc()
Definition: exprtk.hpp:11787
details::stringvar_node< T > stringvar_node_t
Definition: exprtk.hpp:18153
static T process_5(const Sequence &arg_list)
Definition: exprtk.hpp:12354
vector_holder< T > vector_holder_t
Definition: exprtk.hpp:7075
Definition: exprtk.hpp:4406
T operator()(parameter_list_t parameters)
Definition: exprtk.hpp:36545
std::vector< branch_t > branch_
Definition: exprtk.hpp:11594
Definition: exprtk.hpp:31450
T g2d_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1310
Definition: exprtk.hpp:12070
Definition: exprtk.hpp:31746
Definition: exprtk.hpp:4440
T(* bfunc_t)(Type t0, Type t1)
Definition: exprtk.hpp:2005
exprtk_define_erfc(float,::erfcf) exprtk_define_erfc(double
details::T0oT1oT2oT3< T, T0, T1, T2, T3, typename T0oT1oT20T3process< T >::mode4 > type4
Definition: exprtk.hpp:14342
expression_node_ptr parse_function_call(ifunction< T > *function, const std::string &function_name)
Definition: exprtk.hpp:20894
T0oT1oT2oT3_sf4ext< T, T0, T1, T2, T3, SF4Operation > node_type
Definition: exprtk.hpp:14228
Definition: exprtk.hpp:20813
Definition: exprtk.hpp:4429
expression_node_ptr synthesize_sos_expression(const details::operator_type &opr, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33739
expression_node< T >::node_type type() const
Definition: exprtk.hpp:8967
virtual ~polynomial()
Definition: exprtk.hpp:35306
static std::string null_value
Definition: exprtk.hpp:7490
T d2r_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1308
Definition: exprtk.hpp:8734
void clear_vectors()
Definition: exprtk.hpp:16757
expression_node_ptr parse_vector()
Definition: exprtk.hpp:22945
vector_node< T > * vector_node_ptr
Definition: exprtk.hpp:7379
commutative_inserter()
Definition: exprtk.hpp:3177
sos_node< T, SType0, SType1, Operation > & operator=(sos_node< T, SType0, SType1, Operation > &)
std::pair< bool, expression_node_ptr > n1_e
Definition: exprtk.hpp:6943
Definition: exprtk.hpp:4921
dot()
Definition: exprtk.hpp:38084
T value() const
Definition: exprtk.hpp:9457
bool add_constants()
Definition: exprtk.hpp:17225
expression_node< T > * expression_ptr
Definition: exprtk.hpp:9755
Definition: exprtk.hpp:4429
static long double value()
Definition: exprtk.hpp:817
T value() const
Definition: exprtk.hpp:10073
bool is_integer(const T v)
Definition: exprtk.hpp:1524
static expression_node< T > * allocate(Allocator &allocator, T0 p0, T1 p1, T2 p2, bfunc_t p3, bfunc_t p4)
Definition: exprtk.hpp:13827
symbol_list_t assignment_name_list_
Definition: exprtk.hpp:19216
const T & v_
Definition: exprtk.hpp:15227
virtual expression_node< T > * branch(const std::size_t &index=0) const
Definition: exprtk.hpp:4949
expression_node_ptr special_function(const details::operator_type &operation, expression_node_ptr(&branch)[4])
Definition: exprtk.hpp:27009
Definition: exprtk.hpp:26618
std::vector< std::string > retparam_list_t
Definition: exprtk.hpp:19162
std::pair< expression_ptr, bool > branch_t
Definition: exprtk.hpp:5840
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:37696
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:37639
parser_error::type get_error(const std::size_t &index)
Definition: exprtk.hpp:20151
functor_t::bfunc_t bfunc_t
Definition: exprtk.hpp:13464
repeat_until_loop_node(expression_ptr condition, expression_ptr loop_body)
Definition: exprtk.hpp:6222
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:37526
token_t & operator[](const std::size_t &index)
Definition: exprtk.hpp:2278
virtual ~T0oT1oT2_base_node()
Definition: exprtk.hpp:13258
static T_ execute(ifunction &f, T_(&v)[20])
Definition: exprtk.hpp:11162
T value() const
Definition: exprtk.hpp:14460
covocov_t::sf4_type sf4_type
Definition: exprtk.hpp:33398
freefunc15(ff15_functor ff)
Definition: exprtk.hpp:16188
expression_node< T > * expression_ptr
Definition: exprtk.hpp:14832
operator_type operation() const
Definition: exprtk.hpp:14863
void enable_unknown_symbol_resolver(unknown_symbol_resolver &usr)
Definition: exprtk.hpp:20209
T nor_impl(const T v0, const T v1, int_type_tag)
Definition: exprtk.hpp:1142
functor_t::ufunc_t unary_functor_t
Definition: exprtk.hpp:9006
base_func(const std::size_t &pc=0)
Definition: exprtk.hpp:35504
expression_node_ptr const_optimise_switch(Sequence< expression_node_ptr, Allocator > &arg_list)
Definition: exprtk.hpp:26531
Definition: exprtk.hpp:4419
void start()
Definition: exprtk.hpp:36385
vocovov_t::type0 node_type
Definition: exprtk.hpp:30667
expression_node< T > * expression_ptr
Definition: exprtk.hpp:14351
bfunc_t f() const
Definition: exprtk.hpp:13731
Definition: exprtk.hpp:13170
Definition: exprtk.hpp:6164
vovovov_t::sf4_type sf4_type
Definition: exprtk.hpp:32143
~scoped_bool_or_restorer()
Definition: exprtk.hpp:20832
opr_base< T >::Type Type
Definition: exprtk.hpp:12122
static T process_1(const Sequence &arg_list)
Definition: exprtk.hpp:12261
vector_view< T > make_vector_view(T *data, const std::size_t size, const std::size_t offset=0)
Definition: exprtk.hpp:4128
Definition: exprtk.hpp:4410
expression_node< T >::node_type type() const
Definition: exprtk.hpp:7831
ff15_functor f
Definition: exprtk.hpp:16193
std::size_t depth
Definition: exprtk.hpp:18300
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:28571
static bool test(const PtrType, const void *)
Definition: exprtk.hpp:16419
Definition: exprtk.hpp:4432
igeneric_function< T >::parameter_list_t parameter_list_t
Definition: exprtk.hpp:36458
T value() const
Definition: exprtk.hpp:9958
void scan_operator()
Definition: exprtk.hpp:2496
func_5param()
Definition: exprtk.hpp:35797
Definition: exprtk.hpp:17554
static expression_node< T >::node_type type()
Definition: exprtk.hpp:11987
vector_holder< T > vector_holder_t
Definition: exprtk.hpp:7194
expression_node_ptr repeat_until_loop(expression_node_ptr &condition, expression_node_ptr &branch, const bool brkcont=false) const
Definition: exprtk.hpp:26438
vector_node_ptr vec() const
Definition: exprtk.hpp:10780
node_type::T1 T1
Definition: exprtk.hpp:31863
range_t rp_
Definition: exprtk.hpp:7561
static T_ execute(ifunction &f, T_(&v)[3])
Definition: exprtk.hpp:11281
T2 t2_
Definition: exprtk.hpp:13841
disabled_entity_set_t disabled_inequality_set_
Definition: exprtk.hpp:19808
ivararg_function< T > VAF
Definition: exprtk.hpp:18124
any_true< T > nt
Definition: exprtk.hpp:38169
func_6param()
Definition: exprtk.hpp:35811
covovov_t::type0 node_type
Definition: exprtk.hpp:30751
igfun_t::generic_type generic_type
Definition: exprtk.hpp:37007
expression_node_ptr varnode_optimise_sf3(const details::operator_type &operation, expression_node_ptr(&branch)[3])
Definition: exprtk.hpp:26872
Definition: exprtk.hpp:9595
Definition: exprtk.hpp:4393
static T process_5(const Sequence &arg_list)
Definition: exprtk.hpp:12708
void set_ref(data_ptr_t *data_ref)
Definition: exprtk.hpp:4115
vector_holder_t * vector_holder_ptr
Definition: exprtk.hpp:18238
static T process(Type t1, Type t2)
Definition: exprtk.hpp:12168
node_type::T0 T0
Definition: exprtk.hpp:31976
node_type::T0 T0
Definition: exprtk.hpp:30753
uchar_t const * uchar_cptr
Definition: exprtk.hpp:90
T atan2_impl(const T v0, const T v1, real_type_tag)
Definition: exprtk.hpp:1048
virtual ~cov_base_node()
Definition: exprtk.hpp:13116
VarArgFunction * function_
Definition: exprtk.hpp:11403
Definition: exprtk.hpp:4934
bool boc_optimisable(const details::operator_type &operation, expression_node_ptr(&branch)[2]) const
Definition: exprtk.hpp:25895
Definition: exprtk.hpp:19253
static const std::string arithmetic_ops_list[]
Definition: exprtk.hpp:476
node_type::T3 T3
Definition: exprtk.hpp:30840
std::string get_conststr_stringvar_name(const expression_node_ptr &ptr) const
Definition: exprtk.hpp:18935
std::deque< parser_error::type > error_list_
Definition: exprtk.hpp:34657
std::size_t scope_depth
Definition: exprtk.hpp:18993
~bipowninv_node()
Definition: exprtk.hpp:15244
bool is_reserved_symbol(const std::string &symbol)
Definition: exprtk.hpp:513
sort()
Definition: exprtk.hpp:37646
vector_view_t & vec_view_
Definition: exprtk.hpp:5384
details::functor_t< T > functor_t
Definition: exprtk.hpp:14047
T value() const
Definition: exprtk.hpp:6630
static T_ execute(ifunction &f, T_(&v)[6])
Definition: exprtk.hpp:11260
assignment_vec_elem_op_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:9946
bool is_true(const double v)
Definition: exprtk.hpp:4963
unsigned char uchar_t
Definition: exprtk.hpp:86
Definition: exprtk.hpp:17565
Definition: exprtk.hpp:18313
operator_type operation() const
Definition: exprtk.hpp:15059
sf4_map_t * sf4_map_
Definition: exprtk.hpp:34367
std::vector< T > var_t
Definition: exprtk.hpp:35498
precedence_level
Definition: exprtk.hpp:18102
std::vector< lexer::token_inserter * > token_inserter_list
Definition: exprtk.hpp:3940
covovoc_t::type4 node_type
Definition: exprtk.hpp:33510
static void execute(T_(&v)[2], const branch_t(&b)[2])
Definition: exprtk.hpp:11140
T value() const
Definition: exprtk.hpp:10717
Definition: exprtk.hpp:5750
range_t & range_ref()
Definition: exprtk.hpp:8416
Definition: exprtk.hpp:4920
Definition: exprtk.hpp:5886
Definition: exprtk.hpp:18115
bool is_vararg_function(const std::string &vararg_function_name) const
Definition: exprtk.hpp:18887
str_base_ptr str1_base_ptr_
Definition: exprtk.hpp:8218
unknown_symbol_resolver default_usr_
Definition: exprtk.hpp:34663
binary_op_map_t * binary_op_map_
Definition: exprtk.hpp:34364
const range_t & range_ref() const
Definition: exprtk.hpp:8421
vocov_t::sf3_type sf3_type
Definition: exprtk.hpp:29658
Definition: exprtk.hpp:2025
void update(const T &v0, const T &v1, const T &v2)
Definition: exprtk.hpp:35525
details::scand_node< T > scand_node_t
Definition: exprtk.hpp:18170
Definition: exprtk.hpp:36593
Definition: exprtk.hpp:4455
Definition: exprtk.hpp:19273
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:38139
vector_holder_ptr get_vector(const std::string &vector_name) const
Definition: exprtk.hpp:16884
vocovov_t::type3 node_type
Definition: exprtk.hpp:32779
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:32898
bool run_assemblies()
Definition: exprtk.hpp:20060
node_type::T3 T3
Definition: exprtk.hpp:31922
Definition: exprtk.hpp:17969
T2 t2() const
Definition: exprtk.hpp:13801
details::assignment_vec_elem_node< T > assignment_vec_elem_node_t
Definition: exprtk.hpp:18165
static T process(Type t1, Type t2)
Definition: exprtk.hpp:12141
str_base_ptr str0_base_ptr_
Definition: exprtk.hpp:8841
void set(const precedence_level &l, const precedence_level &r, const details::operator_type &o)
Definition: exprtk.hpp:20388
void clear_errors()
Definition: exprtk.hpp:3697
T log_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1294
vector_holder_t * vector_holder_ptr
Definition: exprtk.hpp:7076
lvr_vec_t lv
Definition: exprtk.hpp:35700
vector_node_ptr vec()
Definition: exprtk.hpp:7032
sf4_map_t sf4_map_
Definition: exprtk.hpp:34669
T value() const
Definition: exprtk.hpp:9921
generic_string_range_node(expression_ptr str_branch, const range_t &brange)
Definition: exprtk.hpp:7734
Definition: exprtk.hpp:16023
expression_node< typename ResultNode::value_type > * allocate(OpType &operation, ExprNode(&branch)[1])
Definition: exprtk.hpp:15411
expression_ptr condition_
Definition: exprtk.hpp:6262
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:31629
static T process(const arg_list_t &arg)
Definition: exprtk.hpp:26641
static details::operator_type operation()
Definition: exprtk.hpp:12134
axpbyz< T > b1_axpbyz
Definition: exprtk.hpp:38184
T shr_impl(const T v0, const T v1, int_type_tag)
Definition: exprtk.hpp:1066
void activate_side_effect(const std::string &)
Definition: exprtk.hpp:18975
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:37737
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:37582
T value_type
Definition: exprtk.hpp:13952
T modulus_impl(const T v0, const T v1, real_type_tag)
Definition: exprtk.hpp:929
range_interface< T > irange_t
Definition: exprtk.hpp:8585
expression_node< T > * branch(const std::size_t &index=0) const
Definition: exprtk.hpp:5818
precedence_level left
Definition: exprtk.hpp:20404
const value_t * begin() const
Definition: exprtk.hpp:4250
Definition: exprtk.hpp:17978
virtual bool side_effect() const
Definition: exprtk.hpp:6996
std::size_t current_index_
Definition: exprtk.hpp:3549
Definition: exprtk.hpp:32421
cob_node< T, Operation > & operator=(const cob_node< T, Operation > &)
static T process_1(const Sequence &arg_list)
Definition: exprtk.hpp:12754
bool wc_match(const std::string &wild_card, const std::string &str)
Definition: exprtk.hpp:632
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:31737
bool add_variable(const std::string &variable_name, T &t, const bool is_constant=false)
Definition: exprtk.hpp:16974
Type * ptr_t
Definition: exprtk.hpp:20750
virtual const T & v0() const =0
value_t * begin()
Definition: exprtk.hpp:4251
Definition: exprtk.hpp:14765
expression_node_ptr parse_for_loop()
Definition: exprtk.hpp:21788
expression_node< T > * expression_ptr
Definition: exprtk.hpp:7855
static T process(Type t1, Type t2)
Definition: exprtk.hpp:12083
expression_node_ptr vararg_function_call(ivararg_function_t *vaf, std::vector< expression_node_ptr > &arg_list)
Definition: exprtk.hpp:27223
bool operator!() const
Definition: exprtk.hpp:17737
std::pair< expression_ptr, bool > branch_t
Definition: exprtk.hpp:14658
virtual std::size_t size() const =0
Definition: exprtk.hpp:4150
Definition: exprtk.hpp:4438
vocovoc_t::sf4_type sf4_type
Definition: exprtk.hpp:31025
range_t & range_ref()
Definition: exprtk.hpp:8048
Definition: exprtk.hpp:4394
operator_type operation() const
Definition: exprtk.hpp:13968
array_vector_impl operator=(const array_vector_impl &)
static T process(const arg_list_t &arg)
Definition: exprtk.hpp:26610
T value() const
Definition: exprtk.hpp:6242
operator_type operation() const
Definition: exprtk.hpp:14243
range_pack< T > range_t
Definition: exprtk.hpp:11735
Definition: exprtk.hpp:35150
expression_node< T > * expression_ptr
Definition: exprtk.hpp:6109
virtual T operator()(parameter_list_t) igeneric_function_empty_body(1) inline virtual T operator()(std return_type rtrn_type
Definition: exprtk.hpp:15977
Definition: exprtk.hpp:4448
void * data
Definition: exprtk.hpp:6967
T r2d_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1307
const symbol_table< T > & get_symbol_table(const std::size_t &index=0) const
Definition: exprtk.hpp:17782
bool branch_deletable_
Definition: exprtk.hpp:13440
static T process(const ivector_ptr v)
Definition: exprtk.hpp:13037
bool add_reserved_function(const std::string &vararg_function_name, vararg_function_t &vararg_function)
Definition: exprtk.hpp:17097
Definition: exprtk.hpp:4408
Definition: exprtk.hpp:4437
virtual const T c() const =0
~control_block()
Definition: exprtk.hpp:4574
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:30842
std::list< T > local_symbol_list_
Definition: exprtk.hpp:16650
token_t & next_token()
Definition: exprtk.hpp:2258
lexer::helper::sequence_validator sequence_validator_
Definition: exprtk.hpp:34681
Definition: exprtk.hpp:4918
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:36828
ProcessMode process_mode_t
Definition: exprtk.hpp:13859
bool is_constant_foldable(NodePtr(&b)[N]) const
Definition: exprtk.hpp:27482
const T & ref() const
Definition: exprtk.hpp:7216
static T execute(ifunction &, branch_t(&)[ParamCount])
Definition: exprtk.hpp:11157
T value_t
Definition: exprtk.hpp:4273
Definition: exprtk.hpp:4415
node_type::T0 T0
Definition: exprtk.hpp:31454
covovov_t::sf4_type sf4_type
Definition: exprtk.hpp:32836
T value() const
Definition: exprtk.hpp:9655
expression_node< typename ResultNode::value_type > * allocate(OpType &operation, ExprNode(&branch)[3])
Definition: exprtk.hpp:15423
Definition: exprtk.hpp:12156
T1 t1() const
Definition: exprtk.hpp:13983
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:30138
bool is_constant(const std::string &symbol_name) const
Definition: exprtk.hpp:16256
trinary_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1, expression_ptr branch2)
Definition: exprtk.hpp:5893
Definition: exprtk.hpp:4408
Definition: exprtk.hpp:4400
Definition: exprtk.hpp:4423
void populate_value_list() const
Definition: exprtk.hpp:11395
details::T0oT1oT2_define< T, const_t, cref_t, const_t > covoc_t
Definition: exprtk.hpp:18206
Definition: exprtk.hpp:4453
lexer::token_inserter * error_token_inserter
Definition: exprtk.hpp:3945
opr_base< T >::Type Type
Definition: exprtk.hpp:12421
void register_local_var(vector_holder_ptr vec_holder)
Definition: exprtk.hpp:17848
node_type::T3 T3
Definition: exprtk.hpp:31029
expression_node< T >::node_type type() const
Definition: exprtk.hpp:11834
Definition: exprtk.hpp:5564
std::string type_id() const
Definition: exprtk.hpp:14190
#define def_fp_retval(N)
Definition: exprtk.hpp:35840
vovocov_t::sf4_type sf4_type
Definition: exprtk.hpp:30584
details::node_allocator * node_allocator_
Definition: exprtk.hpp:34361
Definition: exprtk.hpp:4910
assignment_vecvec_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:9759
Definition: exprtk.hpp:2019
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:38046
SType1 s1_
Definition: exprtk.hpp:14818
data_ptr_t data() const
Definition: exprtk.hpp:4095
bool replace_symbol(const std::string &old_symbol, const std::string &new_symbol)
Definition: exprtk.hpp:20179
Definition: exprtk.hpp:4910
copy()
Definition: exprtk.hpp:37388
str_base_ptr str1_base_ptr_
Definition: exprtk.hpp:8568
expression_ptr loop_body_
Definition: exprtk.hpp:6412
Definition: exprtk.hpp:36813
details::sf3ext_type_node< T, T0, T1, T2 > sf3_type_node
Definition: exprtk.hpp:14332
node_type::T1 T1
Definition: exprtk.hpp:32033
expression_node< T >::node_type type() const
Definition: exprtk.hpp:7221
Definition: exprtk.hpp:19298
bool string_to_type_converter_impl_ref(Iterator &itr, const Iterator end, T &result)
Definition: exprtk.hpp:1680
static bool cmp(const char_t c0, const char_t c1)
Definition: exprtk.hpp:575
bool branch_deletable(expression_node< T > *node)
Definition: exprtk.hpp:5136
Definition: exprtk.hpp:4393
Definition: exprtk.hpp:18116
expression_node< typename node_type::value_type > * allocate(const Sequence< Type, Allocator > &seq) const
Definition: exprtk.hpp:15456
T0oT1oT2oT3_sf4(node_type &)
Definition: exprtk.hpp:14210
T3 t3() const
Definition: exprtk.hpp:14180
bool add_reserved_function(const std::string &function_name, generic_function_t &function)
Definition: exprtk.hpp:17109
parser_t & parser_
Definition: exprtk.hpp:23317
Definition: exprtk.hpp:4445
static void print(const string_t &s)
Definition: exprtk.hpp:36502
bool peek_token_is(const token_t::token_type &ttype)
Definition: exprtk.hpp:4045
T sinh_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1300
string_size_node(expression_ptr brnch)
Definition: exprtk.hpp:8265
expression_node< T > * branch(const std::size_t &) const
Definition: exprtk.hpp:14527
virtual std::string type_id() const =0
settings_store & enable_inequality_operation(settings_inequality_opr inequality)
Definition: exprtk.hpp:19709
Definition: exprtk.hpp:4908
expression_node< T >::node_type type() const
Definition: exprtk.hpp:8833
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:32187
expression_node< typename ResultNode::value_type > * allocate(OpType &operation, ExprNode(&branch)[5])
Definition: exprtk.hpp:15435
node_type::T3 T3
Definition: exprtk.hpp:33066
Definition: exprtk.hpp:15933
vector_node< T > * vector_node_ptr
Definition: exprtk.hpp:9639
const T c() const
Definition: exprtk.hpp:14622
dependent_entity_collector dec_
Definition: exprtk.hpp:34656
details::T0oT1oT2_define< T, const_t, const_t, cref_t > cocov_t
Definition: exprtk.hpp:18207
Definition: exprtk.hpp:12080
operator_type operation() const
Definition: exprtk.hpp:13419
details::functor_t< T > functor_t
Definition: exprtk.hpp:14136
vector_node_ptr vec()
Definition: exprtk.hpp:10630
Definition: exprtk.hpp:16000
generic_type::vector_view vector_t
Definition: exprtk.hpp:38080
void set_error(const parser_error::type &error_type)
Definition: exprtk.hpp:34371
vector_node_ptr vec1_node_ptr_
Definition: exprtk.hpp:10501
static void execute(T_(&v)[5], const branch_t(&b)[5])
Definition: exprtk.hpp:11104
void add_invalid(lexer::token::token_type base, lexer::token::token_type t)
Definition: exprtk.hpp:3704
range_t & range_ref()
Definition: exprtk.hpp:5628
file_descriptor(const std::string &fname, const std::string &access)
Definition: exprtk.hpp:36601
node_type::T3 T3
Definition: exprtk.hpp:30387
control_block & operator=(const control_block &)
expression_node< T > * expression_ptr
Definition: exprtk.hpp:10056
bool original_value_
Definition: exprtk.hpp:20838
const ufunc_t u0_
Definition: exprtk.hpp:13383
bool is_string_range_node(const expression_node< T > *node)
Definition: exprtk.hpp:15322
Definition: exprtk.hpp:13639
expression_ptr consequent_
Definition: exprtk.hpp:8729
T value() const
Definition: exprtk.hpp:5444
node_type::T2 T2
Definition: exprtk.hpp:32727
type_map_t::const_iterator tm_const_itr_t
Definition: exprtk.hpp:16214
swap_genstrings_node< T > & operator=(swap_genstrings_node< T > &)
~vec_binop_vecval_node()
Definition: exprtk.hpp:10556
bool operator()(const lexer::token &t0, const lexer::token &t1)
Definition: exprtk.hpp:3663
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:37289
Definition: exprtk.hpp:15996
std::vector< unsigned char > delete_branch_
Definition: exprtk.hpp:6760
T value() const
Definition: exprtk.hpp:10218
assignment_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:9487
generic_type::scalar_view scalar_t
Definition: exprtk.hpp:37107
static T process_5(const Sequence &arg_list)
Definition: exprtk.hpp:12287
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:32543
generic_type::vector_view vector_t
Definition: exprtk.hpp:36953
void clear()
Definition: exprtk.hpp:4366
bool is_constant_foldable(const Sequence< NodePtr, Allocator > &b) const
Definition: exprtk.hpp:27498
static details::operator_type operation()
Definition: exprtk.hpp:11988
bool is_cob_node(const expression_node< T > *node)
Definition: exprtk.hpp:15286
swap_string_node(expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:8001
char_t * char_ptr
Definition: exprtk.hpp:89
T1 t1() const
Definition: exprtk.hpp:14170
Definition: exprtk.hpp:4410
expression_node_ptr synthesize_uv_expression(const details::operator_type &operation, expression_node_ptr(&branch)[1])
Definition: exprtk.hpp:26788
std::size_t assignment_symbols(Sequence< symbol_t, Allocator > &assignment_list)
Definition: exprtk.hpp:19107
expression_node< T > * expression_ptr
Definition: exprtk.hpp:8857
details::expression_node< T > * expression_ptr
Definition: exprtk.hpp:16581
Definition: exprtk.hpp:9977
const range_t & range_ref() const
Definition: exprtk.hpp:8554
lexer::token token_t
Definition: exprtk.hpp:18172
Definition: exprtk.hpp:4914
node_type::T1 T1
Definition: exprtk.hpp:31920
T0oT1oT2_sf3ext(node_type &)
Definition: exprtk.hpp:14109
expression_node< T > * expression_ptr
Definition: exprtk.hpp:10179
range_t rp_
Definition: exprtk.hpp:7716
opr_base< T >::Type Type
Definition: exprtk.hpp:12492
static expression_node< T > * allocate(Allocator &allocator, T0 p0, T1 p1, T2 p2)
Definition: exprtk.hpp:14100
freefunc02(ff02_functor ff)
Definition: exprtk.hpp:16047
void parse_pending_string_rangesize(expression_node_ptr &expression)
Definition: exprtk.hpp:22418
Definition: exprtk.hpp:19066
covocov_t::type3 node_type
Definition: exprtk.hpp:32891
function_traits()
Definition: exprtk.hpp:15758
control_block(const std::size_t &dsize)
Definition: exprtk.hpp:4560
expression_node< T > * expression_ptr
Definition: exprtk.hpp:10330
virtual const T c() const =0
opr_base< T >::Type Type
Definition: exprtk.hpp:12298
token_inserter(const std::size_t &stride)
Definition: exprtk.hpp:2992
std::map< std::string, std::pair< trinary_functor_t,operator_t > > sf3_map_t
Definition: exprtk.hpp:18191
void clear_local_constants()
Definition: exprtk.hpp:16762
node_type::T1 T1
Definition: exprtk.hpp:32669
Definition: exprtk.hpp:4904
str_base_ptr str1_base_ptr_
Definition: exprtk.hpp:7979
virtual operator_type operation() const
Definition: exprtk.hpp:13233
expression_node< T >::node_type type() const
Definition: exprtk.hpp:11388
bool is_base_function(const std::string &function_name)
Definition: exprtk.hpp:526
static expression_node< T >::node_type type()
Definition: exprtk.hpp:12105
T erfc_impl(T v, int_type_tag)
Definition: exprtk.hpp:1248
node_type::T3 T3
Definition: exprtk.hpp:31865
Definition: exprtk.hpp:17973
Definition: exprtk.hpp:37331
const unsigned int global_loop_batch_size
Definition: exprtk.hpp:4505
T0_ T0
Definition: exprtk.hpp:13854
node_type::T2 T2
Definition: exprtk.hpp:31456
range_t * range_ptr
Definition: exprtk.hpp:7997
expression_node_ptr parse_null_statement()
Definition: exprtk.hpp:23656
results_context_t * results_context_
Definition: exprtk.hpp:11895
#define exprtk_disable_fallthrough_begin
Definition: exprtk.hpp:80
void set_bom(binary_op_map_t &binary_op_map)
Definition: exprtk.hpp:25529
expression_ptr branch_
Definition: exprtk.hpp:5700
T2 t2_
Definition: exprtk.hpp:13938
Definition: exprtk.hpp:13484
assignment_string_range_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:8455
vec_data_store(const type &vds)
Definition: exprtk.hpp:4646
unary_op_map_t unary_op_map_
Definition: exprtk.hpp:34665
node_type::T0 T0
Definition: exprtk.hpp:33232
std::size_t size()
Definition: exprtk.hpp:4688
Definition: exprtk.hpp:19284
T value() const
Definition: exprtk.hpp:8020
Definition: exprtk.hpp:35793
details::T0oT1_define< T, const_t, cref_t > cov_t
Definition: exprtk.hpp:18199
expression_node< T > * expression_ptr
Definition: exprtk.hpp:6273
expression_node_ptr parse_while_loop()
Definition: exprtk.hpp:21550
expression_node_ptr parse_vararg_function_call(ivararg_function< T > *vararg_function, const std::string &vararg_function_name)
Definition: exprtk.hpp:23032
static bool is_variable(const expression< T > &expr)
Definition: exprtk.hpp:17933
Definition: exprtk.hpp:4440
generic_function_node< T, igeneric_function_t > gen_function_t
Definition: exprtk.hpp:11807
std::size_t ref_count
Definition: exprtk.hpp:17675
disabled_entity_set_t disabled_logic_set_
Definition: exprtk.hpp:19805
Definition: exprtk.hpp:29715
symbol_table_t::local_data_t local_data_t
Definition: exprtk.hpp:18549
expression_node_ptr synthesize_csocsr_expression(const details::operator_type &opr, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33897
static std::string id()
Definition: exprtk.hpp:13493
vector_node_ptr vec() const
Definition: exprtk.hpp:10132
Definition: exprtk.hpp:14542
vec_binop_vecval_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:10519
Sequence< Type, Allocator > sequence_t
Definition: exprtk.hpp:5323
static expression_node< T >::node_type type()
Definition: exprtk.hpp:12095
Definition: exprtk.hpp:6976
Definition: exprtk.hpp:13445
bool init_branches(expression_ptr(&b)[NumBranches])
Definition: exprtk.hpp:11039
Definition: exprtk.hpp:4931
function_t & setup(expression_t &expr)
Definition: exprtk.hpp:35551
node_type::T1 T1
Definition: exprtk.hpp:32089
std::pair< expression_ptr, bool > branch_t
Definition: exprtk.hpp:14497
details::expression_node< Type > * expression_node_ptr
Definition: exprtk.hpp:25439
irange_ptr str1_range_ptr_
Definition: exprtk.hpp:7981
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:37581
Definition: exprtk.hpp:32140
vds_t & vds()
Definition: exprtk.hpp:10800
Definition: exprtk.hpp:2021
void set_min_num_args(FunctionType &func, const std::size_t &num_args)
Definition: exprtk.hpp:15823
unary_branch_node(expression_ptr brnch)
Definition: exprtk.hpp:13396
#define exprtk_define_unary_function(FunctionName)
Definition: exprtk.hpp:1566
Definition: exprtk.hpp:5581
T value_type
Definition: exprtk.hpp:4938
expression_node< typename node_type::value_type > * allocate_tt(T1 t1, T2 t2) const
Definition: exprtk.hpp:15503
value_ptr value_at(const std::size_t &index) const
Definition: exprtk.hpp:5370
expression_node_ptr const_optimise_varargfunc(const details::operator_type &operation, Sequence< expression_node_ptr, Allocator > &arg_list)
Definition: exprtk.hpp:27044
Definition: exprtk.hpp:4902
Definition: exprtk.hpp:14397
lexer::token token
Definition: exprtk.hpp:17986
Definition: exprtk.hpp:36511
Definition: exprtk.hpp:18106
irange_ptr str1_range_ptr_
Definition: exprtk.hpp:8724
expression_node_ptr special_function(const details::operator_type &operation, expression_node_ptr(&branch)[3])
Definition: exprtk.hpp:26904
Definition: exprtk.hpp:16093
switch_n_node(const Sequence< expression_ptr, Allocator > &arg_list)
Definition: exprtk.hpp:6673
Definition: exprtk.hpp:4412
T value() const
Definition: exprtk.hpp:9499
std::size_t parse_base_function_call(expression_node_ptr(¶m_list)[MaxNumberofParameters], const std::string &function_name="")
Definition: exprtk.hpp:21009
Definition: exprtk.hpp:9519
token_joiner(const std::size_t &stride)
Definition: exprtk.hpp:3078
T frac_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1312
Definition: exprtk.hpp:4450
T or_impl(const T v0, const T v1, real_type_tag)
Definition: exprtk.hpp:1124
static T process(Type t1, Type t2)
Definition: exprtk.hpp:12020
expression_node< typename node_type::value_type > * allocate_type(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7) const
Definition: exprtk.hpp:15676
Definition: exprtk.hpp:28687
static expression_node_ptr process(expression_generator< Type > &, const details::operator_type &, expression_node_ptr(&)[2])
Definition: exprtk.hpp:30126
std::size_t size() const
Definition: exprtk.hpp:10296
vector_node_ptr vec() const
Definition: exprtk.hpp:10625
node_type::T2 T2
Definition: exprtk.hpp:32090
range_list_t range_list_
Definition: exprtk.hpp:11596
details::functor_t< T > functor_t
Definition: exprtk.hpp:13851
vds_t & vds()
Definition: exprtk.hpp:10152
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:37335
axpy()
Definition: exprtk.hpp:37840
Definition: exprtk.hpp:32889
static expression_node< T >::node_type type()
Definition: exprtk.hpp:12023
Definition: exprtk.hpp:4453
details::T0oT1oT2oT3< T, T0, T1, T2, T3, typename T0oT1oT20T3process< T >::mode3 > type3
Definition: exprtk.hpp:14341
static T_ execute(ifunction &f, T_(&v)[13])
Definition: exprtk.hpp:11211
covov_t::sf3_type sf3_type
Definition: exprtk.hpp:29838
T value() const
Definition: exprtk.hpp:14512
expression_node_ptr parse_base_operation()
Definition: exprtk.hpp:21081
~break_node()
Definition: exprtk.hpp:6116
functor_t::ufunc_t ufunc_t
Definition: exprtk.hpp:13325
node_type::T3 T3
Definition: exprtk.hpp:33122
vds_t vds_
Definition: exprtk.hpp:10170
Definition: exprtk.hpp:4915
static T process(Type t1, Type t2)
Definition: exprtk.hpp:12132
Definition: exprtk.hpp:4551
RawType & type_ref(const std::string &symbol_name)
Definition: exprtk.hpp:16484
igfun_t::generic_type generic_type
Definition: exprtk.hpp:36893
Definition: exprtk.hpp:4442
igfun_t::generic_type generic_type
Definition: exprtk.hpp:37528
value_t & operator()()
Definition: exprtk.hpp:4283
Definition: exprtk.hpp:13946
sf3_map_t sf3_map_
Definition: exprtk.hpp:34668
functor_t::bfunc_t bfunc_t
Definition: exprtk.hpp:13324
Definition: exprtk.hpp:11730
T min(const T v0, const T v1)
Definition: exprtk.hpp:1391
T value() const
Definition: exprtk.hpp:14562
vector_node_ptr vec()
Definition: exprtk.hpp:10286
virtual ~boc_base_node()
Definition: exprtk.hpp:13194
range_pack< T > range_t
Definition: exprtk.hpp:8583
bool add_function(const std::string &vararg_function_name, vararg_function_t &vararg_function)
Definition: exprtk.hpp:17027
expression_node_ptr synthesize_str_xoxr_expression_impl(const details::operator_type &opr, T0 s0, T1 s1, range_t rp1)
Definition: exprtk.hpp:33689
bool operator<(const value_t lhs, const value_t rhs) noexcept
comparison operator for JSON types
Definition: json.h:429
bool add(const std::string &symbol_name, std::deque< T, Allocator > &v, const bool is_const=false)
Definition: exprtk.hpp:16357
expression_node< typename ResultNode::value_type > * allocate(OpType &operation, ExprNode(&branch)[4])
Definition: exprtk.hpp:15429
Definition: exprtk.hpp:12363
vocovoc_t::sf4_type sf4_type
Definition: exprtk.hpp:33454
bool add(const std::string &symbol_name, T(&v)[v_size], const bool is_const=false)
Definition: exprtk.hpp:16331
virtual operator_type operation() const
Definition: exprtk.hpp:13101
expression_node< T > * expression_ptr
Definition: exprtk.hpp:6220
vector_holder(std::vector< Type, Allocator > &vec)
Definition: exprtk.hpp:5400
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1)
Definition: exprtk.hpp:29889
sf3_map_t * sf3_map_
Definition: exprtk.hpp:34366
static st_data * create()
Definition: exprtk.hpp:16639
axpbz()
Definition: exprtk.hpp:38036
Definition: exprtk.hpp:30123
Definition: exprtk.hpp:28435
variable_t * variable_ptr
Definition: exprtk.hpp:16584
vovovoc_t::sf4_type sf4_type
Definition: exprtk.hpp:32199
expression_node_ptr vectorize_func(const details::operator_type &operation, Sequence< expression_node_ptr, Allocator > &arg_list)
Definition: exprtk.hpp:27111
Definition: exprtk.hpp:4413
Definition: exprtk.hpp:29414
node_type::T1 T1
Definition: exprtk.hpp:30838
virtual operator_type operation() const
Definition: exprtk.hpp:13247
Definition: exprtk.hpp:4416
const bool condition_deletable_
Definition: exprtk.hpp:6264
const range_t & range_ref() const
Definition: exprtk.hpp:5633
vovocov_t::type0 node_type
Definition: exprtk.hpp:30583
std::vector< std::pair< lexer::token, lexer::token > > error_list_
Definition: exprtk.hpp:3788
nthelement< T > ne
Definition: exprtk.hpp:38178
node_type::T1 T1
Definition: exprtk.hpp:32539
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:37290
Definition: exprtk.hpp:31972
Definition: exprtk.hpp:17975
error_mode mode
Definition: exprtk.hpp:17987
node_type::T3 T3
Definition: exprtk.hpp:32371
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:28689
static T process(const Sequence< Type, Allocator > &arg_list)
Definition: exprtk.hpp:12568
node_type::T0 T0
Definition: exprtk.hpp:33175
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33124
bool is_stringvar(const std::string &stringvar_name) const
Definition: exprtk.hpp:17343
exprtk::symbol_table< T > symbol_table_t
Definition: exprtk.hpp:35396
expression_node< T > * expression_ptr
Definition: exprtk.hpp:7132
Definition: exprtk.hpp:4403
Definition: exprtk.hpp:4921
cob_node(const T const_var, const expression_ptr brnch)
Definition: exprtk.hpp:14601
bool src_is_ivec_
Definition: exprtk.hpp:9898
long long int to_int64(const T v)
Definition: exprtk.hpp:1377
int vn
Definition: obj.cpp:20
bool is_constant_string(const std::string &symbol_name) const
Definition: exprtk.hpp:16929
virtual void set_c(const T)=0
bool allow_zero_parameters() const
Definition: exprtk.hpp:23221
Definition: exprtk.hpp:4435
std::size_t size
Definition: exprtk.hpp:17593
T value() const
Definition: exprtk.hpp:11328
Definition: exprtk.hpp:4450
node_type::T3 T3
Definition: exprtk.hpp:33402
Definition: exprtk.hpp:19272
details::literal_node< T > literal_node_t
Definition: exprtk.hpp:18130
Definition: exprtk.hpp:13592
vector_node_ptr vec() const
Definition: exprtk.hpp:7441
symbol_table_t & get_symbol_table(const std::size_t &index=0)
Definition: exprtk.hpp:18951
type_map_t map
Definition: exprtk.hpp:16218
expression_node< T > * expression_ptr
Definition: exprtk.hpp:11316
~const_string_range_node()
Definition: exprtk.hpp:7666
Operation operation_t
Definition: exprtk.hpp:14659
Definition: exprtk.hpp:12419
exprtk_define_freefunction(00) exprtk_define_freefunction(01) exprtk_define_freefunction(02) exprtk_define_freefunction(03) exprtk_define_freefunction(04) exprtk_define_freefunction(05) exprtk_define_freefunction(06) exprtk_define_freefunction(07) exprtk_define_freefunction(08) exprtk_define_freefunction(09) exprtk_define_freefunction(10) exprtk_define_freefunction(11) exprtk_define_freefunction(12) exprtk_define_freefunction(13) exprtk_define_freefunction(14) exprtk_define_freefunction(15) inline bool add_reserved_function(const std
Definition: exprtk.hpp:17074
virtual void reset()
Definition: exprtk.hpp:2856
details::vector_holder< T > vector_t
Definition: exprtk.hpp:16204
Definition: exprtk.hpp:4904
Definition: exprtk.hpp:32028
opr_base< T >::Type Type
Definition: exprtk.hpp:12643
Definition: exprtk.hpp:4902
Definition: exprtk.hpp:4459
static T process(const arg_list_t &arg)
Definition: exprtk.hpp:26620
Definition: exprtk.hpp:4398
T equal(const T v0, const T v1)
Definition: exprtk.hpp:1405
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1)
Definition: exprtk.hpp:29527
vec_data_store< T > vds_t
Definition: exprtk.hpp:10181
opr_base< T >::Type Type
Definition: exprtk.hpp:12072
expression_node< T > * expression_ptr
Definition: exprtk.hpp:9388
vocovov_t::type1 node_type
Definition: exprtk.hpp:31804
node_type::T0 T0
Definition: exprtk.hpp:31642
vector_node_ptr temp_vec_node_
Definition: exprtk.hpp:10966
static void execute(Sequence< std::pair< expression_node< T > *, bool >, Allocator > &branch)
Definition: exprtk.hpp:5767
expression_node< T > * expression_node_ptr
Definition: exprtk.hpp:6827
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:37197
type_store & operator[](const std::size_t &index)
Definition: exprtk.hpp:4182
Definition: exprtk.hpp:4436
Definition: exprtk.hpp:4458
bool in_use_
Definition: exprtk.hpp:36427
settings_store & enable_all_base_functions()
Definition: exprtk.hpp:19323
igeneric_function< T >::parameter_list_t parameter_list_t
Definition: exprtk.hpp:36535
T value() const
Definition: exprtk.hpp:5852
static expression_node_ptr process(expression_generator< Type > &, const details::operator_type &, expression_node_ptr(&)[2])
Definition: exprtk.hpp:32594
Definition: exprtk.hpp:14447
conditional_node(expression_ptr test, expression_ptr consequent, expression_ptr alternative)
Definition: exprtk.hpp:5986
Definition: exprtk.hpp:4933
const bool condition_deletable_
Definition: exprtk.hpp:6211
Definition: exprtk.hpp:4393
vds_t & vds()
Definition: exprtk.hpp:10952
Definition: exprtk.hpp:754
T ceil_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1289
generic_type::vector_view vector_t
Definition: exprtk.hpp:37741
const vds_t & vds() const
Definition: exprtk.hpp:9738
unary_variable_node(const T &var)
Definition: exprtk.hpp:13283
value_ptr operator[](const std::size_t &index) const
Definition: exprtk.hpp:5408
replace_map_t replace_map_
Definition: exprtk.hpp:3617
node_type::T3 T3
Definition: exprtk.hpp:31753
Operation operation_t
Definition: exprtk.hpp:14770
vector_node_ptr vec0_node_ptr_
Definition: exprtk.hpp:10964
virtual operator_type operation() const
Definition: exprtk.hpp:13197
T value() const
Definition: exprtk.hpp:9268
bool register_inserter(lexer::token_inserter *inserter)
Definition: exprtk.hpp:3835
T log2_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1296
std::size_t size() const
Definition: exprtk.hpp:7816
any_false()
Definition: exprtk.hpp:37296
details::functor_t< T > functor_t
Definition: exprtk.hpp:13950
virtual const T c() const =0
Definition: exprtk.hpp:10051
details::trinary_node< T > trinary_node_t
Definition: exprtk.hpp:18133
bool all_nodes_valid(expression_node< T > *(&b)[N])
Definition: exprtk.hpp:5143
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:32525
vector_holder_ptr get_vector(const std::string &vector_name) const
Definition: exprtk.hpp:18745
bool is_invalid_assignment_operation(const details::operator_type operation)
Definition: exprtk.hpp:20268
results_context_t * results_context_
Definition: exprtk.hpp:11841
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:32205
SType0 s0_
Definition: exprtk.hpp:14880
Definition: exprtk.hpp:4905
std::string type_id() const
Definition: exprtk.hpp:14273
voc_node(const T &var, const T &const_var)
Definition: exprtk.hpp:14455
const e_voc T1 e_none const e_none T1 e_none T0
Definition: exprtk.hpp:13638
std::size_t get_list(Sequence< std::pair< std::string, RawType >, Allocator > &list) const
Definition: exprtk.hpp:16538
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:31031
Definition: exprtk.hpp:4432
vector_node_ptr vec() const
Definition: exprtk.hpp:7027
node_type::T0 T0
Definition: exprtk.hpp:30501
std::vector< unsigned char > delete_branch_
Definition: exprtk.hpp:8980
Definition: exprtk.hpp:4910
Definition: exprtk.hpp:32945
bool parsing_break_stmt
Definition: exprtk.hpp:18989
static T process(const Sequence< Type, Allocator > &arg_list)
Definition: exprtk.hpp:12370
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:37945
expression_ptr test_
Definition: exprtk.hpp:8728
expression_node< T >::node_type type() const
Definition: exprtk.hpp:15054
details::T0oT1oT2oT3< T, T0, T1, T2, T3, typename T0oT1oT20T3process< T >::mode0 > type0
Definition: exprtk.hpp:14338
bool add_epsilon()
Definition: exprtk.hpp:17239
expression_node_ptr synthesize_srosr_expression(const details::operator_type &opr, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33786
bool vob_optimisable(const details::operator_type &operation, expression_node_ptr(&branch)[2]) const
Definition: exprtk.hpp:25945
Definition: exprtk.hpp:4458
std::string branch_to_id(expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:25854
Definition: exprtk.hpp:4149
bool join(const lexer::token &t0, const lexer::token &t1, const lexer::token &t2, lexer::token &t)
Definition: exprtk.hpp:3385
Definition: exprtk.hpp:4924
bool is_string_operation(const details::operator_type &operation, expression_node_ptr(&branch)[3])
Definition: exprtk.hpp:26069
Definition: exprtk.hpp:4402
Definition: exprtk.hpp:19263
details::range_pack< T > range_t
Definition: exprtk.hpp:18151
T0oT1oT2oT3(T0 p0, T1 p1, T2 p2, T3 p3, bfunc_t p4, bfunc_t p5, bfunc_t p6)
Definition: exprtk.hpp:13861
Definition: exprtk.hpp:28276
std::size_t vec_size_
Definition: exprtk.hpp:7475
bool sequence_check_enabled() const
Definition: exprtk.hpp:19430
bool operator==(const expression< T > &e)
Definition: exprtk.hpp:17732
~vectorize_node()
Definition: exprtk.hpp:9449
T value() const
Definition: exprtk.hpp:8640
Definition: exprtk.hpp:2018
expression_node< T >::node_type type() const
Definition: exprtk.hpp:13341
vector_holder< T > vector_holder_t
Definition: exprtk.hpp:7133
generic_function_ptr get_generic_function(const std::string &function_name) const
Definition: exprtk.hpp:16862
Definition: exprtk.hpp:13033
Definition: exprtk.hpp:4401
expression_node< T >::node_type type() const
Definition: exprtk.hpp:6466
Definition: exprtk.hpp:4451
vds_t & vds()
Definition: exprtk.hpp:7047
bool verify(const std::string ¶m_seq, std::size_t &pseq_index)
Definition: exprtk.hpp:23146
vararg_node(const Sequence< expression_ptr, Allocator > &arg_list)
Definition: exprtk.hpp:9332
covocov_t::sf4_type sf4_type
Definition: exprtk.hpp:32424
bool is_vector(const std::string &vector_name) const
Definition: exprtk.hpp:18903
const range_t & range_ref() const
Definition: exprtk.hpp:8828
void set_sf4m(sf4_map_t &sf4_map)
Definition: exprtk.hpp:25544
std::vector< const T * > arg_list_
Definition: exprtk.hpp:9426
static T process(const std::string &t1, const std::string &t2)
Definition: exprtk.hpp:12084
Definition: exprtk.hpp:753
expression_node_ptr parse_function_invocation(ifunction< T > *function, const std::string &function_name)
Definition: exprtk.hpp:20841
freefunc11(ff11_functor ff)
Definition: exprtk.hpp:16141
T0 t0_
Definition: exprtk.hpp:14213
Definition: exprtk.hpp:12028
Definition: exprtk.hpp:4920
Definition: exprtk.hpp:4454
node_type::T1 T1
Definition: exprtk.hpp:32950
println(const std::string &scalar_format="%10.5f")
Definition: exprtk.hpp:36539
std::size_t get_vector_list(Sequence< std::string, Allocator > &vlist) const
Definition: exprtk.hpp:17301
T value() const
Definition: exprtk.hpp:5907
T xor_impl(const T v0, const T v1, real_type_tag)
Definition: exprtk.hpp:1148
~switch_node()
Definition: exprtk.hpp:6619
const T & Type
Definition: exprtk.hpp:2001
std::pair< expression_ptr, bool > branch_t
Definition: exprtk.hpp:5946
read< T > r
Definition: exprtk.hpp:37048
std::size_t vector_count() const
Definition: exprtk.hpp:16803
parser_helper prsrhlpr_t
Definition: exprtk.hpp:18223
scor_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:11001
function & var(const std::string &v)
Definition: exprtk.hpp:35480
void advance_token(const token_advance_mode mode)
Definition: exprtk.hpp:4008
Definition: exprtk.hpp:6269
std::vector< data_pack > local_data_list_t
Definition: exprtk.hpp:17596
std::vector< type_store_t > ts_list_t
Definition: exprtk.hpp:4371
Definition: exprtk.hpp:32608
expression_node< T >::node_type type() const
Definition: exprtk.hpp:9307
str_base_ptr str0_base_ptr_
Definition: exprtk.hpp:8721
igfun_t::generic_type generic_type
Definition: exprtk.hpp:38124
vocovoc_t::sf4_type sf4_type
Definition: exprtk.hpp:31975
T erf_impl(T v, int_type_tag)
Definition: exprtk.hpp:1222
str_xoxr_node(SType0 p0, SType1 p1, RangePack rp1)
Definition: exprtk.hpp:14836
virtual std::string str() const =0
static expression_node< T >::node_type type()
Definition: exprtk.hpp:12189
assignment_op_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:9909
Definition: exprtk.hpp:4901
std::vector< T > value_list_
Definition: exprtk.hpp:11405
Definition: exprtk.hpp:4438
symbol_type
Definition: exprtk.hpp:19053
expression_node_ptr parse_string_function_call(igeneric_function< T > *function, const std::string &function_name)
Definition: exprtk.hpp:23460
branch_t branch_[1]
Definition: exprtk.hpp:15264
const bool alternative_deletable_
Definition: exprtk.hpp:6035
Definition: exprtk.hpp:36865
virtual ~T0oT1oT2oT3_base_node()
Definition: exprtk.hpp:13269
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:36818
T value() const
Definition: exprtk.hpp:14612
const T & type
Definition: exprtk.hpp:35721
bool collect_assignments_
Definition: exprtk.hpp:19212
scope_element null_element_
Definition: exprtk.hpp:18504
bfunc_t f1() const
Definition: exprtk.hpp:13901
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:37351
bool all_nodes_valid(const Sequence< expression_node< T > *, Allocator > &b)
Definition: exprtk.hpp:5156
T nor_opr(const T v0, const T v1)
Definition: exprtk.hpp:1503
scand_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:10977
static T process_6(const Sequence &arg_list)
Definition: exprtk.hpp:12794
type_checker(parser_t &p, const std::string &func_name, const std::string ¶m_seq)
Definition: exprtk.hpp:23136
while_loop_node(expression_ptr condition, expression_ptr loop_body)
Definition: exprtk.hpp:6170
virtual std::size_t size() const =0
std::size_t size
Definition: exprtk.hpp:18298
Definition: exprtk.hpp:13070
details::generic_string_range_node< T > generic_string_range_node_t
Definition: exprtk.hpp:18157
stringvar_node< T > * strvar_node_ptr
Definition: exprtk.hpp:8448
Definition: exprtk.hpp:16601
static expression_node< T >::node_type type()
Definition: exprtk.hpp:12055
expression_node_ptr cardinal_pow_optimisation(expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:28090
Definition: exprtk.hpp:35155
expression_node_ptr simplify(Sequence< expression_node_ptr, Allocator1 > &expression_list, Sequence< bool, Allocator2 > &side_effect_list, const bool specialise_on_final_type=false)
Definition: exprtk.hpp:22441
opr_base< T >::Type Type
Definition: exprtk.hpp:12006
std::string * value_
Definition: exprtk.hpp:7645
T csc_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1306
T atan_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1287
Definition: exprtk.hpp:26639
details::assignment_string_range_node< T > assignment_string_range_node_t
Definition: exprtk.hpp:18160
Definition: exprtk.hpp:4435
string_base_node< T > * str_base_ptr
Definition: exprtk.hpp:7856
details::vector_holder< T > * vector_holder_ptr
Definition: exprtk.hpp:17562
static T process_3(const Sequence &arg_list)
Definition: exprtk.hpp:12537
std::string & s0()
Definition: exprtk.hpp:14743
Definition: exprtk.hpp:2024
T value() const
Definition: exprtk.hpp:6190
static T process(const T &t0, const T &t1, const T &t2)
Definition: exprtk.hpp:12207
virtual bool result()
Definition: exprtk.hpp:2857
Definition: exprtk.hpp:17573
std::string data_
Definition: exprtk.hpp:414
bool add_constant(const std::string &constant_name, const T &value)
Definition: exprtk.hpp:16986
irange_ptr str0_range_ptr_
Definition: exprtk.hpp:8723
generic_type::scalar_view scalar_t
Definition: exprtk.hpp:37383
expression< T > & operator=(const expression< T > &e)
Definition: exprtk.hpp:17707
details::T0oT1oT2oT3_define< T, const_t, cref_t, cref_t, cref_t > covovov_t
Definition: exprtk.hpp:18214
bool is_null_present(expression_node_ptr(&branch)[2]) const
Definition: exprtk.hpp:26093
bool local_variable_is_shadowed(const std::string &symbol)
Definition: exprtk.hpp:24154
const T & v_
Definition: exprtk.hpp:14438
expression_node< T > * expression_ptr
Definition: exprtk.hpp:6591
control_block * control_block_
Definition: exprtk.hpp:17548
T * data_t
Definition: exprtk.hpp:4547
node_type::T3 T3
Definition: exprtk.hpp:31697
static T process_4(const Sequence &arg_list)
Definition: exprtk.hpp:12347
IFunction ifunction
Definition: exprtk.hpp:11026
static T_ execute(ifunction &f, T_(&v)[17])
Definition: exprtk.hpp:11183
bool retinv_null
Definition: exprtk.hpp:17679
GenericFunction * function_
Definition: exprtk.hpp:11588
Definition: exprtk.hpp:4924
T value() const
Definition: exprtk.hpp:6444
virtual std::string & ref()
Definition: exprtk.hpp:7618
T value() const
Definition: exprtk.hpp:7266
igfun_t::generic_type generic_type
Definition: exprtk.hpp:37640
static T process(const arg_list_t &arg)
Definition: exprtk.hpp:26630
Definition: exprtk.hpp:4430
T root(const T v0, const T v1)
Definition: exprtk.hpp:1440
expression_node_ptr parse_vararg_function()
Definition: exprtk.hpp:22284
Definition: exprtk.hpp:7312
settings_store & enable_all_arithmetic_ops()
Definition: exprtk.hpp:19341
Definition: exprtk.hpp:13530
Definition: exprtk.hpp:37193
bool synthesize_expression(const details::operator_type &operation, expression_node_ptr(&branch)[2], expression_node_ptr &result)
Definition: exprtk.hpp:29049
Operation operation_t
Definition: exprtk.hpp:13281
range_t * range_ptr
Definition: exprtk.hpp:8078
literal_node(literal_node< T > &)
Definition: exprtk.hpp:5535
type_store< T > generic_type
Definition: exprtk.hpp:11790
const std::size_t size_
Definition: exprtk.hpp:7307
range_ptr str1_range_ptr_
Definition: exprtk.hpp:8437
bool return_present() const
Definition: exprtk.hpp:19152
std::string str() const
Definition: exprtk.hpp:7806
opr_base< T >::Type Type
Definition: exprtk.hpp:12158
range_pack< T > range_t
Definition: exprtk.hpp:8334
Definition: exprtk.hpp:4916
store_type
Definition: exprtk.hpp:4146
expression_node< T >::node_type type() const
Definition: exprtk.hpp:7361
bool valid() const
Definition: exprtk.hpp:18569
expression_node< T >::node_type type() const
Definition: exprtk.hpp:14149
static T process(const std::string &t1, const std::string &t2)
Definition: exprtk.hpp:12094
T value() const
Definition: exprtk.hpp:9244
static T process(const ivector_ptr v)
Definition: exprtk.hpp:12835
Definition: exprtk.hpp:4455
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1)
Definition: exprtk.hpp:30116
T value() const
Definition: exprtk.hpp:14360
Definition: exprtk.hpp:37973
vector_holder_t & vec_holder()
Definition: exprtk.hpp:7226
T0oT1oT2oT3_sf4(T0 p0, T1 p1, T2 p2, T3 p3, const qfunc_t p4)
Definition: exprtk.hpp:14141
static T evaluate(const Type x, const Type c7, const Type c6, const Type c5, const Type c4, const Type c3, const Type c2, const Type c1, const Type c0)
Definition: exprtk.hpp:35223
expression_node_ptr synthesize_assignment_operation_expression(const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:27618
cocov_t::type0 node_type
Definition: exprtk.hpp:30125
expression_node< T > * expression_ptr
Definition: exprtk.hpp:5653
ff10_functor f
Definition: exprtk.hpp:16134
T value() const
Definition: exprtk.hpp:14160
bool operator()(std::size_t &r0, std::size_t &r1, const std::size_t &size=std::numeric_limits< std::size_t >::max()) const
Definition: exprtk.hpp:6888
operator_type operation() const
Definition: exprtk.hpp:14370
expression_ptr return_
Definition: exprtk.hpp:6139
T value() const
Definition: exprtk.hpp:5476
Definition: exprtk.hpp:4400
BaseFuncType & bft_
Definition: exprtk.hpp:35729
Definition: exprtk.hpp:18231
Definition: exprtk.hpp:17971
std::string & s1()
Definition: exprtk.hpp:14873
virtual operator_type operation() const
Definition: exprtk.hpp:13217
str_xroxr_node< T, SType0, SType1, RangePack, Operation > & operator=(str_xroxr_node< T, SType0, SType1, RangePack, Operation > &)
lexer::helper::commutative_inserter commutative_inserter_
Definition: exprtk.hpp:34675
covov_t::type0 node_type
Definition: exprtk.hpp:29777
node_type::T2 T2
Definition: exprtk.hpp:31644
symbol_table_t & symbol_table()
Definition: exprtk.hpp:35916
Definition: exprtk.hpp:18113
node_type::T2 T2
Definition: exprtk.hpp:30671
covovoc_t::sf4_type sf4_type
Definition: exprtk.hpp:33511
Definition: exprtk.hpp:4905
Definition: exprtk.hpp:4446
Definition: exprtk.hpp:15948
Definition: exprtk.hpp:4446
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:31459
std::set< std::string > reserved_symbol_table_
Definition: exprtk.hpp:16652
bool strength_reduction_enabled() const
Definition: exprtk.hpp:19431
Definition: exprtk.hpp:19257
bool run_scanners(lexer::generator &g)
Definition: exprtk.hpp:3915
void load_inv_binary_operations_map(inv_binary_op_map_t &m)
Definition: exprtk.hpp:34532
Definition: exprtk.hpp:4420
T value() const
Definition: exprtk.hpp:17757
bool to_uint(UIntType &u) const
Definition: exprtk.hpp:4305
~expression()
Definition: exprtk.hpp:17752
expression_node< T > * expression_ptr
Definition: exprtk.hpp:6669
shift_right< T > sr
Definition: exprtk.hpp:38176
std::size_t size
Definition: exprtk.hpp:16219
generic_type::scalar_view scalar_t
Definition: exprtk.hpp:36895
static expression_node< T >::node_type type()
Definition: exprtk.hpp:12045
bool return_invoked_
Definition: exprtk.hpp:11896
Definition: exprtk.hpp:37043
vector_node_ptr vec()
Definition: exprtk.hpp:9718
static T process(const Sequence< Type, Allocator > &arg_list)
Definition: exprtk.hpp:12728
generic_type::vector_view vector_t
Definition: exprtk.hpp:37292
#define exprtk_process_digit
expression_node_ptr synthesize_csocs_expression(const details::operator_type &opr, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33866
bool enable_collect_assings_
Definition: exprtk.hpp:19798
functor_t::tfunc_t tfunc_t
Definition: exprtk.hpp:14048
symbol_table< T > & get_symbol_table(const std::size_t &index=0)
Definition: exprtk.hpp:17787
Definition: exprtk.hpp:4921
lexer::helper::symbol_replacer symbol_replacer_
Definition: exprtk.hpp:34678
Definition: exprtk.hpp:4439
ufunc_t f()
Definition: exprtk.hpp:13371
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:37152
static void process(std::pair< expression_node< T > *, bool >(&branch)[N], expression_node< T > *b)
Definition: exprtk.hpp:5716
generator_t & lexer()
Definition: exprtk.hpp:3970
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:33219
vec_data_store< T > vds_t
Definition: exprtk.hpp:9640
const bfunc_t f2_
Definition: exprtk.hpp:13942
std::size_t size() const
Definition: exprtk.hpp:10795
T value() const
Definition: exprtk.hpp:13973
bool is_invalid(const char_t c)
Definition: exprtk.hpp:152
freefunc09(ff09_functor ff)
Definition: exprtk.hpp:16119
T value() const
Definition: exprtk.hpp:10983
node_type::T2 T2
Definition: exprtk.hpp:33177
bool initialised_
Definition: exprtk.hpp:7977
node_type::T1 T1
Definition: exprtk.hpp:31266
static expression_node< T >::node_type type()
Definition: exprtk.hpp:12133
Definition: exprtk.hpp:15838
Definition: exprtk.hpp:4444
Definition: exprtk.hpp:33339
static expression_node< T > * allocate(Allocator &allocator, T0 p0, T1 p1, bfunc_t p2)
Definition: exprtk.hpp:13737
const range_t & range_ref() const
Definition: exprtk.hpp:7548
operator_type operation_
Definition: exprtk.hpp:5975
static std::string id()
Definition: exprtk.hpp:13520
#define basic_opr_switch_statements
Definition: exprtk.hpp:28012
details::binary_node< T > binary_node_t
Definition: exprtk.hpp:18132
token & set_string(const std::string &s, const std::size_t p)
Definition: exprtk.hpp:2088
ivariable_ptr var1_
Definition: exprtk.hpp:7369
Definition: exprtk.hpp:28126
Definition: exprtk.hpp:35493
variable_node_t * variable_node_ptr
Definition: exprtk.hpp:18237
~scoped_vec_delete()
Definition: exprtk.hpp:20791
static details::operator_type operation()
Definition: exprtk.hpp:12096
Definition: exprtk.hpp:4434
str_sogens_node< T, Operation > & operator=(str_sogens_node< T, Operation > &)
void free_all_nodes(NodeAllocator &node_allocator, Sequence< expression_node< T > *, Allocator > &b)
Definition: exprtk.hpp:5209
expression_node< T >::node_type type() const
Definition: exprtk.hpp:8207
rebasevector_elem_node(expression_ptr index, vector_holder_ptr vec_holder)
Definition: exprtk.hpp:7137
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:33442
exprtk::parser< T > parser_t
Definition: exprtk.hpp:35397
node_type::T0 T0
Definition: exprtk.hpp:32200
node_type::T2 T2
Definition: exprtk.hpp:31978
bool is_rebasevector_elem_node(const expression_node< T > *node)
Definition: exprtk.hpp:5039
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:29720
T shr(const T v0, const T v1)
Definition: exprtk.hpp:1468
char_cptr base() const
Definition: exprtk.hpp:8406
Definition: exprtk.hpp:4452
const bool branch_deletable_
Definition: exprtk.hpp:5505
multimode_genfunction_node(GenericFunction *func, const std::size_t ¶m_seq_index, const std::vector< typename gen_function_t::expression_ptr > &arg_list)
Definition: exprtk.hpp:11693
void dump(lexer::generator &generator)
Definition: exprtk.hpp:3158
token & set_operator(const token_type tt, const Iterator begin, const Iterator end, const Iterator base_begin=Iterator(0))
Definition: exprtk.hpp:2047
bool destruct
Definition: exprtk.hpp:4616
Definition: exprtk.hpp:19299
Definition: exprtk.hpp:4420
Definition: exprtk.hpp:752
Definition: exprtk.hpp:4448
vococ_t::sf3_type sf3_type
Definition: exprtk.hpp:30249
T1 t1_
Definition: exprtk.hpp:13840
std::pair< bool, expression_node_ptr > n0_e
Definition: exprtk.hpp:6942
expression_node_ptr parse_string()
Definition: exprtk.hpp:22782
static details::operator_type operation()
Definition: exprtk.hpp:12035
T0 t0() const
Definition: exprtk.hpp:14074
Definition: exprtk.hpp:4929
all_true< T > at
Definition: exprtk.hpp:38167
node_type::T3 T3
Definition: exprtk.hpp:33009
covovov_t::sf4_type sf4_type
Definition: exprtk.hpp:33342
void store_token()
Definition: exprtk.hpp:3980
bool is_vector_elem_node(const expression_node< T > *node)
Definition: exprtk.hpp:5033
vovocov_t::type3 node_type
Definition: exprtk.hpp:32723
Definition: exprtk.hpp:12831
expression_node< T > * branch(const std::size_t &) const
Definition: exprtk.hpp:5497
st_data * data_
Definition: exprtk.hpp:16700
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:33499
vector_node_ptr vec()
Definition: exprtk.hpp:10785
std::vector< T > tmp_vs_t
Definition: exprtk.hpp:11424
expression_node< T > * expression_ptr
Definition: exprtk.hpp:6422
Definition: exprtk.hpp:4917
freefunc10(ff10_functor ff)
Definition: exprtk.hpp:16130
bool valid_string_operation(const details::operator_type &operation) const
Definition: exprtk.hpp:25742
Definition: exprtk.hpp:8258
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:32412
char_cptr base() const
Definition: exprtk.hpp:7811
literal_node< T > & operator=(literal_node< T > &)
Definition: exprtk.hpp:5536
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:33386
static const std::string logic_ops_list[]
Definition: exprtk.hpp:462
const vds_t & vds() const
Definition: exprtk.hpp:7466
multi_switch_node(const Sequence< expression_ptr, Allocator > &arg_list)
Definition: exprtk.hpp:6692
#define exprtk_crtype(Type)
Definition: exprtk.hpp:13457
vector_node_ptr vec()
Definition: exprtk.hpp:9868
settings_control_structs
Definition: exprtk.hpp:19269
IFunction ifunction
Definition: exprtk.hpp:11317
std::vector< lexer::token_modifier * > token_modifier_list
Definition: exprtk.hpp:3938
bipow_node< T, PowOp > & operator=(const bipow_node< T, PowOp > &)
Definition: exprtk.hpp:4906
Definition: exprtk.hpp:1362
std::map< std::string, synthesize_functor_t > synthesize_map_t
Definition: exprtk.hpp:25441
details::quaternary_node< T > quaternary_node_t
Definition: exprtk.hpp:18134
Definition: exprtk.hpp:4220
local_data_t & local_data(const std::size_t &index=0)
Definition: exprtk.hpp:18941
T0 t0() const
Definition: exprtk.hpp:13791
std::size_t stringvar_count() const
Definition: exprtk.hpp:16786
covocov_t::type4 node_type
Definition: exprtk.hpp:33397
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:37850
std::size_t next_ip_index()
Definition: exprtk.hpp:18469
Definition: exprtk.hpp:4397
expression_node_ptr synthesize_socs_expression(const details::operator_type &opr, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33802
boc_node< T, Operation > & operator=(const boc_node< T, Operation > &)
Definition: exprtk.hpp:19256
str_sogens_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:14978
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:38028
Definition: exprtk.hpp:30581
Definition: exprtk.hpp:4916
bool initialised_
Definition: exprtk.hpp:8720
type_store()
Definition: exprtk.hpp:16221
generic_type::vector_view vector_t
Definition: exprtk.hpp:37836
Definition: exprtk.hpp:4426
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:38077
void deactivate(const std::size_t &scope_depth)
Definition: exprtk.hpp:18410
static T process(const T &t0, const T &t1, const T &t2, const bfunc_t bf0, const bfunc_t bf1)
Definition: exprtk.hpp:13468
vob_node(const T &var, const expression_ptr brnch)
Definition: exprtk.hpp:14501
generic_type::scalar_view scalar_t
Definition: exprtk.hpp:37698
std::map< std::string, type_pair_t, details::ilesscompare > type_map_t
Definition: exprtk.hpp:16212
void set_c(const T new_c)
Definition: exprtk.hpp:14627
string_function_node(StringFunction *func, const std::vector< typename gen_function_t::expression_ptr > &arg_list)
Definition: exprtk.hpp:11610
T value() const
Definition: exprtk.hpp:6523
T0oT1oT2_sf3ext< T, T0, T1, T2, SF3Operation > node_type
Definition: exprtk.hpp:14050
scope_element & get_element(const std::size_t &index)
Definition: exprtk.hpp:18336
bool imatch(const char_t c1, const char_t c2)
Definition: exprtk.hpp:174
irange_ptr str_range_ptr_
Definition: exprtk.hpp:7842
static expression_node_ptr error_node()
Definition: exprtk.hpp:20705
Definition: exprtk.hpp:4452
T value() const
Definition: exprtk.hpp:10403
range_pack< T > range_t
Definition: exprtk.hpp:7996
node_type::T1 T1
Definition: exprtk.hpp:30586
expression_node< T > * expression_ptr
Definition: exprtk.hpp:15080
vec_data_store()
Definition: exprtk.hpp:4634
std::vector< expression_ptr > initialiser_list_
Definition: exprtk.hpp:7306
node_type::T1 T1
Definition: exprtk.hpp:31643
synthesize_map_t synthesize_map_
Definition: exprtk.hpp:34362
vector_holder(exprtk::vector_view< Type > &vec)
Definition: exprtk.hpp:5404
Definition: exprtk.hpp:4330
const T & v2_
Definition: exprtk.hpp:9285
T roundn_impl(const T v0, const T v1, real_type_tag)
Definition: exprtk.hpp:1018
Definition: exprtk.hpp:4923
Definition: exprtk.hpp:26608
binary_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:5787
Definition: exprtk.hpp:15134
Definition: exprtk.hpp:4411
functor_t::bfunc_t bfunc_t
Definition: exprtk.hpp:13852
bool post_bracket_process(const typename token_t::token_type &token, expression_node_ptr &branch)
Definition: exprtk.hpp:24809
bool has_side_effects_
Definition: exprtk.hpp:15788
generic_type::vector_view vector_t
Definition: exprtk.hpp:37246
T value() const
Definition: exprtk.hpp:11007
bool register_modifier(lexer::token_modifier *modifier)
Definition: exprtk.hpp:3807
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1)
Definition: exprtk.hpp:29467
vector_node< T > * vec1_node_ptr_
Definition: exprtk.hpp:7474
node_type::T0 T0
Definition: exprtk.hpp:32032
ff09_functor f
Definition: exprtk.hpp:16123
variable_ptr get_variable(const std::string &variable_name) const
Definition: exprtk.hpp:18599
Definition: exprtk.hpp:2029
shift_left< T > sl
Definition: exprtk.hpp:38175
usr_mode mode
Definition: exprtk.hpp:19013
expression_node< T >::node_type type() const
Definition: exprtk.hpp:10942
void dump_ptr(const std::string &, const void *)
Definition: exprtk.hpp:4537
const char_t & back(const std::string &s)
Definition: exprtk.hpp:256
igfun_t::generic_type generic_type
Definition: exprtk.hpp:37697
expression_node< T >::node_type type() const
Definition: exprtk.hpp:5523
opr_base< T >::Type Type
Definition: exprtk.hpp:12092
Definition: exprtk.hpp:12060
void add_assignment(const std::string &symbol, const symbol_type st)
Definition: exprtk.hpp:19194
T0oT1oT2< T, T0, T1, T2, ProcessMode > node_type
Definition: exprtk.hpp:13764
expression_node_ptr parse_conditional_statement()
Definition: exprtk.hpp:21392
~function_N_node()
Definition: exprtk.hpp:11033
~vector_assignment_node()
Definition: exprtk.hpp:7255
Definition: exprtk.hpp:4912
Definition: exprtk.hpp:2022
std::string str() const
Definition: exprtk.hpp:8033
std::vector< type_store > & parameter_list_
Definition: exprtk.hpp:4214
T value() const
Definition: exprtk.hpp:14728
st_data()
Definition: exprtk.hpp:16613
const T c() const
Definition: exprtk.hpp:14683
sf4_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1, expression_ptr branch2, expression_ptr branch3)
Definition: exprtk.hpp:9236
Definition: exprtk.hpp:758
tfunc_t f() const
Definition: exprtk.hpp:13993
vector_node_ptr vec()
Definition: exprtk.hpp:7446
all_true()
Definition: exprtk.hpp:37158
node_type::T2 T2
Definition: exprtk.hpp:32202
node_type::T0 T0
Definition: exprtk.hpp:31694
bool is_vov_node(const expression_node< T > *node)
Definition: exprtk.hpp:15268
Definition: exprtk.hpp:4933
Definition: exprtk.hpp:13443
operator_type operation() const
Definition: exprtk.hpp:5492
T0oT1oT2(T0 p0, T1 p1, T2 p2, const bfunc_t p3, const bfunc_t p4)
Definition: exprtk.hpp:13767
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &sf4opr, T0 t0, T1 t1, T2 t2, T3 t3)
Definition: exprtk.hpp:29220
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:37397
bool add_impl(const std::string &symbol_name, RType t, const bool is_const)
Definition: exprtk.hpp:16272
void ignore_symbol(const std::string &symbol)
Definition: exprtk.hpp:3181
Definition: exprtk.hpp:38165
Definition: exprtk.hpp:38024
Definition: exprtk.hpp:7342
Definition: exprtk.hpp:7849
lexer::token_joiner * error_token_joiner
Definition: exprtk.hpp:3944
void clear()
Definition: exprtk.hpp:19128
details::char_cptr base_itr_
Definition: exprtk.hpp:2841
bool is_constant_node(const std::string &symbol_name) const
Definition: exprtk.hpp:16918
Definition: exprtk.hpp:16053
range_t range_
Definition: exprtk.hpp:8725
value_ptr value_at(const std::size_t &index) const
Definition: exprtk.hpp:5331
vococ_t::type0 node_type
Definition: exprtk.hpp:30370
bool is_swap_node(const expression_node< T > *node)
Definition: exprtk.hpp:5105
type()
Definition: exprtk.hpp:17980
settings_store & disable_all_assignment_ops()
Definition: exprtk.hpp:19401
bool add_function(const std::string &function_name, function_t &function)
Definition: exprtk.hpp:17015
bool collect_variables_
Definition: exprtk.hpp:19210
variable_ptr get_variable(const T &var_ref) const
Definition: exprtk.hpp:16821
static std::string null_value
Definition: exprtk.hpp:8229
Definition: exprtk.hpp:4399
local_data_list_t local_data_list
Definition: exprtk.hpp:17677
Definition: exprtk.hpp:4900
string_function_node< T, StringFunction > str_function_t
Definition: exprtk.hpp:11734
T const_pi_impl(real_type_tag)
Definition: exprtk.hpp:1315
bool pgo_primer()
Definition: exprtk.hpp:36134
bool getline(std::string &s)
Definition: exprtk.hpp:36731
Definition: exprtk.hpp:12100
std::size_t vector_size() const
Definition: exprtk.hpp:5336
expression_ptr v_
Definition: exprtk.hpp:9476
Definition: exprtk.hpp:4918
unsigned long long int usec_time() const
Definition: exprtk.hpp:36397
const T & v() const
Definition: exprtk.hpp:13302
return_node(const std::vector< typename gen_function_t::expression_ptr > &arg_list, results_context_t &rc)
Definition: exprtk.hpp:11810
const bool test_deletable_
Definition: exprtk.hpp:6033
static T process(Type t1, Type t2)
Definition: exprtk.hpp:12053
#define register_sf3_extid(Id, Op)
details::char_t char_t
Definition: exprtk.hpp:2192
std::size_t paramseq_count() const
Definition: exprtk.hpp:23206
virtual operator_type operation() const
Definition: exprtk.hpp:13119
T value() const
Definition: exprtk.hpp:15249
bool add_pi()
Definition: exprtk.hpp:17232
std::pair< expression_ptr, bool > branch_t
Definition: exprtk.hpp:15169
expression_node< T > * expression_ptr
Definition: exprtk.hpp:13322
const T & v0() const
Definition: exprtk.hpp:14375
build_string(const std::size_t &initial_size=64)
Definition: exprtk.hpp:385
Definition: exprtk.hpp:4426
static T process(Type t1, Type t2)
Definition: exprtk.hpp:12159
expression_node_ptr parse_conditional_statement_01(expression_node_ptr condition)
Definition: exprtk.hpp:21148
expression_node< T > * expression_ptr
Definition: exprtk.hpp:10824
bool & collect_variables()
Definition: exprtk.hpp:19137
static bool compile_left(expression_generator< Type > &expr_gen, ExternalType t, const details::operator_type &operation, expression_node_ptr &sf3node, expression_node_ptr &result)
Definition: exprtk.hpp:29328
bool add(const std::string &symbol_name, std::vector< T, Allocator > &v, const bool is_const=false)
Definition: exprtk.hpp:16344
igfun_t::generic_type generic_type
Definition: exprtk.hpp:36950
expression_node_ptr parse_switch_statement()
Definition: exprtk.hpp:22023
T1 t1() const
Definition: exprtk.hpp:13881
node_type::T2 T2
Definition: exprtk.hpp:32370
variable_node< T > * var_node_ptr_
Definition: exprtk.hpp:9936
operator_type operation() const
Definition: exprtk.hpp:14617
struct timeval stop_time_
Definition: exprtk.hpp:36435
bool is_vector_arithmetic_operation(const details::operator_type &operation, expression_node_ptr(&branch)[2]) const
Definition: exprtk.hpp:26123
static const std::string base_function_list[]
Definition: exprtk.hpp:447
node_type::T0 T0
Definition: exprtk.hpp:32893
Definition: exprtk.hpp:12016
bool side_effect() const
Definition: exprtk.hpp:10162
bool is_variable(const std::string &variable_name) const
Definition: exprtk.hpp:18815
file_descriptor * make_handle(T v)
Definition: exprtk.hpp:36784
bool valid_function(const std::string &symbol) const
Definition: exprtk.hpp:17510
igfun_t::generic_type generic_type
Definition: exprtk.hpp:37199
ifunction * function_
Definition: exprtk.hpp:11343
T(* qfunc_t)(Type t0, Type t1, Type t2, Type t3)
Definition: exprtk.hpp:2003
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33011
Definition: exprtk.hpp:10509
const range_t & range_ref() const
Definition: exprtk.hpp:7965
vovocov_t::sf4_type sf4_type
Definition: exprtk.hpp:32255
char_cptr base() const
Definition: exprtk.hpp:8693
expression_node< T > * expression_ptr
Definition: exprtk.hpp:8262
rebasevector_elem_node< T > * rbvec_node_ptr_
Definition: exprtk.hpp:10010
vector_holder_ptr vector_holder_
Definition: exprtk.hpp:7183
const type_store & back() const
Definition: exprtk.hpp:4207
Definition: exprtk.hpp:13276
Definition: exprtk.hpp:2017
Definition: exprtk.hpp:2969
node_type::T2 T2
Definition: exprtk.hpp:32951
Definition: exprtk.hpp:13447
const T & v() const
Definition: exprtk.hpp:14522
Definition: exprtk.hpp:2022
T or_opr(const T v0, const T v1)
Definition: exprtk.hpp:1496
functor_t::ufunc_t unary_functor_t
Definition: exprtk.hpp:18183
Definition: exprtk.hpp:4933
T value() const
Definition: exprtk.hpp:10032
igfun_t::generic_type generic_type
Definition: exprtk.hpp:36819
bool read(View &view, const std::size_t amount, const std::size_t offset=0)
Definition: exprtk.hpp:36713
generic_type::scalar_view scalar_t
Definition: exprtk.hpp:37529
generic_type::string_view string_t
Definition: exprtk.hpp:36951
node_type::T2 T2
Definition: exprtk.hpp:33345
Definition: exprtk.hpp:4927
details::functor_t< T > functor_t
Definition: exprtk.hpp:14225
branch_t branch_[2]
Definition: exprtk.hpp:5882
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:38029
T value() const
Definition: exprtk.hpp:14069
range_pack< T > range_t
Definition: exprtk.hpp:8742
expression_node< T > * expression_ptr
Definition: exprtk.hpp:7378
T value() const
Definition: exprtk.hpp:14912
std::size_t vector_size() const
Definition: exprtk.hpp:5375
bool is_assignment_operation(const details::operator_type &operation) const
Definition: exprtk.hpp:25729
static void execute(T_(&v)[BranchCount], const branch_t(&b)[BranchCount])
Definition: exprtk.hpp:11092
Definition: exprtk.hpp:16033
std::string & s0()
Definition: exprtk.hpp:14943
expression_node< T >::node_type type() const
Definition: exprtk.hpp:14858
expression_ptr consequent_
Definition: exprtk.hpp:8847
Definition: exprtk.hpp:19266
Definition: exprtk.hpp:18232
Definition: exprtk.hpp:4447
node_type::T3 T3
Definition: exprtk.hpp:31979
std::string get_variable_name(const expression_node_ptr &ptr) const
Definition: exprtk.hpp:18919
virtual const T & v() const =0
expression_node< T > * expression_ptr
Definition: exprtk.hpp:8740
variable_node< T > * var_node_ptr_
Definition: exprtk.hpp:9515
precedence_level right
Definition: exprtk.hpp:20405
static bool is_function(const expression< T > &expr)
Definition: exprtk.hpp:17948
vds_t vds_
Definition: exprtk.hpp:10505
T axn(T a, T x)
Definition: exprtk.hpp:8985
T value() const
Definition: exprtk.hpp:11625
bool is_const_string_range_node(const expression_node< T > *node)
Definition: exprtk.hpp:15334
expression_ptr loop_body_
Definition: exprtk.hpp:6348
Definition: exprtk.hpp:4446
Definition: exprtk.hpp:31915
ivariable< T > * ivariable_ptr
Definition: exprtk.hpp:7347
T value() const
Definition: exprtk.hpp:8930
~null_eq_node()
Definition: exprtk.hpp:5468
expression_node< T >::node_type type() const
Definition: exprtk.hpp:11768
T equal_impl(const T v0, const T v1, real_type_tag)
Definition: exprtk.hpp:873
bool valid_operator(const details::operator_type &operation, binary_functor_t &bop)
Definition: exprtk.hpp:25564
generic_type::vector_view vector_t
Definition: exprtk.hpp:37699
Definition: exprtk.hpp:4427
rol< T > rl
Definition: exprtk.hpp:38173
Definition: exprtk.hpp:4510
expression_node< T >::node_type type() const
Definition: exprtk.hpp:13414
strvar_node_ptr str0_node_ptr_
Definition: exprtk.hpp:8066
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:33275
range_interface< T > irange_t
Definition: exprtk.hpp:8452
Definition: exprtk.hpp:4926
std::string scalar_format_
Definition: exprtk.hpp:36529
node_type::T3 T3
Definition: exprtk.hpp:32203
expression_node< T >::node_type type() const
Definition: exprtk.hpp:10291
std::vector< expression_ptr > arg_list_
Definition: exprtk.hpp:11593
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:30506
vocovoc_t::type2 node_type
Definition: exprtk.hpp:32480
T value() const
Definition: exprtk.hpp:15145
static T process(const std::string &t1, const std::string &t2)
Definition: exprtk.hpp:12074
variable_node_ptr var1_
Definition: exprtk.hpp:7338
T operator()(parameter_list_t parameters)
Definition: exprtk.hpp:36523
details::T0oT1_define< T, cref_t, cref_t > vov_t
Definition: exprtk.hpp:18198
details::for_loop_bc_node< T > for_loop_bc_node_t
Definition: exprtk.hpp:18143
vector_holder< T > * vector_holder_ptr
Definition: exprtk.hpp:10516
base_ops_map_t base_ops_map_
Definition: exprtk.hpp:34664
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:32131
std::size_t type_size
Definition: exprtk.hpp:6969
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:32730
std::vector< token_t > token_list_t
Definition: exprtk.hpp:2190
bool collect_functions(const std::string &expr_str, Sequence< std::string, Allocator > &symbol_list)
Definition: exprtk.hpp:34763
T value() const
Definition: exprtk.hpp:13716
T1 t1() const
Definition: exprtk.hpp:13726
static T process(const Sequence< Type, Allocator > &arg_list)
Definition: exprtk.hpp:12236
static void execute(std::string &s, char_cptr data, const std::size_t size)
Definition: exprtk.hpp:8320
~repeat_until_loop_bc_node()
Definition: exprtk.hpp:6431
igeneric_function< T >::parameter_list_t parameter_list_t
Definition: exprtk.hpp:36513
range_t & range_ref()
Definition: exprtk.hpp:8823
static T process_2(const Sequence &arg_list)
Definition: exprtk.hpp:12267
bool is_variable_node(const expression_node< T > *node)
Definition: exprtk.hpp:5015
T type
Definition: exprtk.hpp:15958
Definition: exprtk.hpp:4397
Definition: exprtk.hpp:4902
cocov_t::sf3_type sf3_type
Definition: exprtk.hpp:30136
Definition: exprtk.hpp:4408
T value() const
Definition: exprtk.hpp:6312
Definition: exprtk.hpp:36346
expression_node< T > * branch(const std::size_t &) const
Definition: exprtk.hpp:13424
node_type::T1 T1
Definition: exprtk.hpp:33233
bool is_cov_node(const expression_node< T > *node)
Definition: exprtk.hpp:15274
operator_type operation() const
Definition: exprtk.hpp:14064
Definition: exprtk.hpp:4925
bool write(const View &view, const std::size_t amount, const std::size_t offset=0)
Definition: exprtk.hpp:36694
Definition: exprtk.hpp:9903
static float value()
Definition: exprtk.hpp:807
bool post_variable_process(const std::string &symbol)
Definition: exprtk.hpp:24784
T or_impl(const T v0, const T v1, int_type_tag)
Definition: exprtk.hpp:1130
Definition: exprtk.hpp:4935
static T process_8(const Sequence &arg_list)
Definition: exprtk.hpp:12817
function_ptr get_function(const std::string &function_name) const
Definition: exprtk.hpp:18661
static T process(const T &t0, const T &t1, const T &t2, const T &t3, const bfunc_t bf0, const bfunc_t bf1, const bfunc_t bf2)
Definition: exprtk.hpp:13573
const std::string value_
Definition: exprtk.hpp:5643
T xor_opr(const T v0, const T v1)
Definition: exprtk.hpp:1510
Definition: exprtk.hpp:9256
Definition: exprtk.hpp:13661
node_type::T0 T0
Definition: exprtk.hpp:30837
T value() const
Definition: exprtk.hpp:6727
void free_all_nodes(NodeAllocator &node_allocator, expression_node< T > *(&b)[N])
Definition: exprtk.hpp:5197
Definition: exprtk.hpp:4905
Definition: exprtk.hpp:12229
virtual bool rebaseable() const
Definition: exprtk.hpp:5363
Definition: exprtk.hpp:4911
lexer::helper::bracket_checker bracket_checker_
Definition: exprtk.hpp:34679
break_node(expression_ptr ret=expression_ptr(0))
Definition: exprtk.hpp:6111
Definition: exprtk.hpp:4917
vector_holder_ptr temp_
Definition: exprtk.hpp:10658
vector_node< T > * vector_node_ptr
Definition: exprtk.hpp:6980
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:36817
T value() const
Definition: exprtk.hpp:6677
virtual bool rebaseable() const
Definition: exprtk.hpp:5272
expression_node< T > * expression_ptr
Definition: exprtk.hpp:13393
rebasevector_celem_node< T > * rbvec_node_ptr_
Definition: exprtk.hpp:9629
Definition: exprtk.hpp:4432
T value_type
Definition: exprtk.hpp:13853
vector_node< T > * vec1_node_ptr_
Definition: exprtk.hpp:9896
freefunc12(ff12_functor ff)
Definition: exprtk.hpp:16152
range_t range_
Definition: exprtk.hpp:11680
bool is_logic_opr(const std::string &lgc_opr)
Definition: exprtk.hpp:552
generic_type::vector_view vector_t
Definition: exprtk.hpp:36896
int to_int32(const T v)
Definition: exprtk.hpp:1370
details::operator_type get_operator(const binary_functor_t &bop)
Definition: exprtk.hpp:25588
static details::operator_type operation()
Definition: exprtk.hpp:12024
static std::string id()
Definition: exprtk.hpp:13582
vector_node< T > * vector_node_ptr
Definition: exprtk.hpp:10670
std::vector< funcparam_t > fp_map_
Definition: exprtk.hpp:36129
std::size_t stack_depth
Definition: exprtk.hpp:35702
static expression_node< T >::node_type type()
Definition: exprtk.hpp:12169
Definition: exprtk.hpp:4904
inv_binary_op_map_t inv_binary_op_map_
Definition: exprtk.hpp:34667
Definition: exprtk.hpp:14891
expression_node< T >::node_type type() const
Definition: exprtk.hpp:6568
const std::size_t stride_
Definition: exprtk.hpp:2966
expression_node< T > * expression_ptr
Definition: exprtk.hpp:14769
vocovoc_t::type3 node_type
Definition: exprtk.hpp:32947
covocov_t::type0 node_type
Definition: exprtk.hpp:30835
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:37789
covovov_t::type3 node_type
Definition: exprtk.hpp:32835
T0 t0_
Definition: exprtk.hpp:14021
expression_node< T >::node_type type() const
Definition: exprtk.hpp:6811
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:29840
std::string type_id() const
Definition: exprtk.hpp:13911
range_t & range_ref()
Definition: exprtk.hpp:8703
node_type::T2 T2
Definition: exprtk.hpp:31808
node_type::T0 T0
Definition: exprtk.hpp:32482
Definition: exprtk.hpp:4396
bool empty() const
Definition: exprtk.hpp:4172
Definition: exprtk.hpp:7239
const range_t & range_ref() const
Definition: exprtk.hpp:7826
dependent_entity_collector & dec()
Definition: exprtk.hpp:20174
const T & v0_
Definition: exprtk.hpp:9283
bool remove_stringvar(const std::string &string_name)
Definition: exprtk.hpp:17192
T shr_impl(const T v0, const T v1, real_type_tag)
Definition: exprtk.hpp:1060
expression_node< T > * expression_ptr
Definition: exprtk.hpp:15168
char_t const * char_cptr
Definition: exprtk.hpp:91
Definition: exprtk.hpp:8575
virtual T operator()() empty_method_body inline virtual T operator()(const T &) empty_method_body inline virtual T operator()(const T &
node_type::T0 T0
Definition: exprtk.hpp:31026
base_operation_t(const operator_type t, const unsigned int &np)
Definition: exprtk.hpp:4493
vector_interface< T > * ivector_ptr
Definition: exprtk.hpp:12934
Definition: exprtk.hpp:4433
T * value_
Definition: exprtk.hpp:6818
quaternary_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1, expression_ptr branch2, expression_ptr branch3)
Definition: exprtk.hpp:5948
bool cob_optimisable(const details::operator_type &operation, expression_node_ptr(&branch)[2]) const
Definition: exprtk.hpp:25886
static details::operator_type operation()
Definition: exprtk.hpp:12143
covovoc_t::type2 node_type
Definition: exprtk.hpp:32536
unary_node(const operator_type &opr, expression_ptr brnch)
Definition: exprtk.hpp:5655
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x(y+z)
static const std::size_t reserved_symbols_size
Definition: exprtk.hpp:445
T nequal_impl(const T v0, const T v1, real_type_tag)
Definition: exprtk.hpp:908
void enable_has_side_effects(FunctionType &func)
Definition: exprtk.hpp:15811
expression_ptr condition_
Definition: exprtk.hpp:6209
virtual ~vector_holder_base()
Definition: exprtk.hpp:5255
vds_t & vds()
Definition: exprtk.hpp:10301
vector_node< T > * vec_node_ptr_
Definition: exprtk.hpp:10169
void cleanup_escapes(std::string &s)
Definition: exprtk.hpp:335
vds_t & vds()
Definition: exprtk.hpp:10488
range_pack< T > range_t
Definition: exprtk.hpp:11691
Definition: exprtk.hpp:37026
unsigned int num_params
Definition: exprtk.hpp:4499
std::string get_conststr_stringvar_name(const expression_ptr &ptr) const
Definition: exprtk.hpp:17407
vocov_t::type0 node_type
Definition: exprtk.hpp:29657
void next_token()
Definition: exprtk.hpp:3992
freefunc14(ff14_functor ff)
Definition: exprtk.hpp:16176
const bool index_deletable_
Definition: exprtk.hpp:7123
Definition: exprtk.hpp:4905
static expression_node< T >::node_type type()
Definition: exprtk.hpp:12085
Definition: exprtk.hpp:4445
static void assign(RefType t1, Type t2)
Definition: exprtk.hpp:11986
T & ref()
Definition: exprtk.hpp:7211
Definition: exprtk.hpp:30246
vector_view(data_ptr_t data, const std::size_t &size)
Definition: exprtk.hpp:4070
bool is_nan_impl(const T v, real_type_tag)
Definition: exprtk.hpp:825
token_t current_token_
Definition: exprtk.hpp:4058
function_compositor(const symbol_table_t &st)
Definition: exprtk.hpp:35904
expression_node< T >::node_type type() const
Definition: exprtk.hpp:14237
void reset()
Definition: exprtk.hpp:3506
type_store< typename details::variable_node< T >, T > variable_store
Definition: exprtk.hpp:16603
std::string & s1()
Definition: exprtk.hpp:14748
igfun_t::generic_type generic_type
Definition: exprtk.hpp:37583
details::T0oT1oT2oT3< T, T0, T1, T2, T3, typename T0oT1oT20T3process< T >::mode1 > type1
Definition: exprtk.hpp:14339
T1 t1() const
Definition: exprtk.hpp:14258
node_type::T3 T3
Definition: exprtk.hpp:32147
vovovoc_t::sf4_type sf4_type
Definition: exprtk.hpp:31693
bool is_string_assignment_node(const expression_node< T > *node)
Definition: exprtk.hpp:15340
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:33106
sosos_node< T, SType0, SType1, SType2, Operation > & operator=(sosos_node< T, SType0, SType1, SType2, Operation > &)
static T_ execute(ifunction &f, T_(&v)[8])
Definition: exprtk.hpp:11246
static std::pair< bool, vector_t * > make(std::pair< T *, std::size_t > v, const bool is_const=false)
Definition: exprtk.hpp:16298
void clear()
Definition: exprtk.hpp:18564
bool assignment_enabled(const details::operator_type &assignment)
Definition: exprtk.hpp:19472
Definition: exprtk.hpp:16126
vector_holder_ptr vec_holder_
Definition: exprtk.hpp:7121
Definition: exprtk.hpp:18229
vds_t vds_
Definition: exprtk.hpp:10815
std::string src_location
Definition: exprtk.hpp:17989
bool simplify_unary_negation_branch(expression_node_ptr &node)
Definition: exprtk.hpp:20650
Definition: exprtk.hpp:2018
expression_node< typename node_type::value_type > * allocate_rrr(T1 &t1, T2 &t2, T3 &t3) const
Definition: exprtk.hpp:15524
T & ref()
Definition: exprtk.hpp:7098
std::size_t size
Definition: exprtk.hpp:6968
details::char_cptr s_end_
Definition: exprtk.hpp:2843
bool bracket_check_enabled() const
Definition: exprtk.hpp:19429
virtual ~igeneric_function()
Definition: exprtk.hpp:15967
ff07_functor f
Definition: exprtk.hpp:16101
details::functor_t< T > functor_t
Definition: exprtk.hpp:18179
vector_holder< T > * vector_holder_ptr
Definition: exprtk.hpp:10671
expression_node< T >::node_type type() const
Definition: exprtk.hpp:11299
str_base_ptr str_base_ptr_
Definition: exprtk.hpp:7841
static control_block * create()
Definition: exprtk.hpp:16674
Definition: exprtk.hpp:9324
Definition: exprtk.hpp:4908
node_type::T2 T2
Definition: exprtk.hpp:32146
Definition: exprtk.hpp:16197
expression_node_ptr synthesize_assignment_expression(const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:27561
T2 t2_
Definition: exprtk.hpp:14114
vector_holder_t & vec_holder()
Definition: exprtk.hpp:7057
bool final_stmt_return_
Definition: exprtk.hpp:19214
expression_ptr index_
Definition: exprtk.hpp:7120
symbol_table_t::variable_ptr variable_ptr
Definition: exprtk.hpp:18550
bfunc_t f0() const
Definition: exprtk.hpp:13806
expression_node_ptr varnode_optimise_sf4(const details::operator_type &operation, expression_node_ptr(&branch)[4])
Definition: exprtk.hpp:26975
parser< T > & parser_
Definition: exprtk.hpp:20805
expression_ptr test_
Definition: exprtk.hpp:6082
const T & v_
Definition: exprtk.hpp:14482
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:32487
Definition: exprtk.hpp:4148
results_context< T > results_context_t
Definition: exprtk.hpp:18221
Definition: exprtk.hpp:12490
bool initialised_
Definition: exprtk.hpp:8433
generic_function_node(const std::vector< expression_ptr > &arg_list, GenericFunction *func=(GenericFunction *)(0))
Definition: exprtk.hpp:11428
generic_type::scalar_view scalar_t
Definition: exprtk.hpp:37882
Definition: exprtk.hpp:30665
std::string inequality_opr_to_string(details::operator_type opr)
Definition: exprtk.hpp:19773
Definition: exprtk.hpp:6101
Definition: exprtk.hpp:31638
Definition: exprtk.hpp:4922
Definition: exprtk.hpp:4405
virtual ~unknown_symbol_resolver()
Definition: exprtk.hpp:19019
println< T > pl
Definition: exprtk.hpp:36559
vocovov_t::sf4_type sf4_type
Definition: exprtk.hpp:33287
generic_type::vector_view vector_t
Definition: exprtk.hpp:37154
details::functor_t< T > functor_t
Definition: exprtk.hpp:13761
func_2param()
Definition: exprtk.hpp:35755
expression_node< T >::node_type type() const
Definition: exprtk.hpp:11883
T sgn_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1084
T process(const operator_type operation, const T arg0, const T arg1)
Definition: exprtk.hpp:4886
void update(const T &v0, const T &v1, const T &v2, const T &v3, const T &v4, const T &v5)
Definition: exprtk.hpp:35544
node_type::T1 T1
Definition: exprtk.hpp:33120
Definition: exprtk.hpp:4409
Definition: exprtk.hpp:19259
Definition: exprtk.hpp:2026
Definition: exprtk.hpp:16104
operator_joiner(const std::size_t &stride)
Definition: exprtk.hpp:3236
operator_type operation() const
Definition: exprtk.hpp:14678
break_exception(const T &v)
Definition: exprtk.hpp:6094
node_type::T1 T1
Definition: exprtk.hpp:30502
Definition: exprtk.hpp:13617
std::vector< lexer::token_joiner * > token_joiner_list
Definition: exprtk.hpp:3939
Definition: exprtk.hpp:4930
file_mode mode
Definition: exprtk.hpp:36608
bool resolve_unknown_symbol_
Definition: exprtk.hpp:34660
T asinh_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1286
Definition: exprtk.hpp:4934
expression_node< T >::node_type type() const
Definition: exprtk.hpp:14415
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:31647
expression_node< T > * expression_ptr
Definition: exprtk.hpp:7346
node_type::T3 T3
Definition: exprtk.hpp:32728
node_type::T0 T0
Definition: exprtk.hpp:31806
static T process(const T &t0, const T &t1, const T &t2, const T &t3, const bfunc_t bf0, const bfunc_t bf1, const bfunc_t bf2)
Definition: exprtk.hpp:13511
std::size_t get_stringvar_list(Sequence< std::string, Allocator > &svlist) const
Definition: exprtk.hpp:17290
Definition: exprtk.hpp:13452
expression_node_ptr switch_statement(Sequence< expression_node_ptr, Allocator > &arg_list)
Definition: exprtk.hpp:26692
static const double pi_4
Definition: exprtk.hpp:741
bool all_nodes_variables(expression_node< T > *(&b)[N])
Definition: exprtk.hpp:5167
char_cptr base() const
Definition: exprtk.hpp:11658
vovocov_t::type4 node_type
Definition: exprtk.hpp:33230
virtual vector_node_ptr vec() const =0
void clear_errors()
Definition: exprtk.hpp:3542
T hypot_impl(const T v0, const T v1, real_type_tag)
Definition: exprtk.hpp:1036
expression_node< typename node_type::value_type > * allocate_rr(T1 &t1, T2 &t2) const
Definition: exprtk.hpp:15496
const T value_
Definition: exprtk.hpp:5538
std::size_t error_count() const
Definition: exprtk.hpp:3679
int upper_bound
Definition: exprtk.hpp:4521
expression_node< T > * expression_ptr
Definition: exprtk.hpp:7243
#define register_op(Symbol, Type, Args)
Definition: exprtk.hpp:37474
#define exprtk_register_complex_type_tag(T)
Definition: exprtk.hpp:768
Definition: exprtk.hpp:4405
static std::string id()
Definition: exprtk.hpp:13603
bool binext_optimisable(const details::operator_type &operation, expression_node_ptr(&branch)[2]) const
Definition: exprtk.hpp:25963
const local_data_t & local_data() const
Definition: exprtk.hpp:17543
void clear_strings()
Definition: exprtk.hpp:16750
Definition: exprtk.hpp:4439
Definition: exprtk.hpp:4430
expression_node< T > * expression_ptr
Definition: exprtk.hpp:8331
copy< T > cp
Definition: exprtk.hpp:38172
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1)
Definition: exprtk.hpp:30002
bool sf3_optimisable(const std::string &sf3id, trinary_functor_t &tfunc)
Definition: exprtk.hpp:25647
bool arithmetic_enabled(const details::operator_type &arithmetic_operation)
Definition: exprtk.hpp:19463
static T process_1(const Sequence &arg_list)
Definition: exprtk.hpp:12385
void scan_number()
Definition: exprtk.hpp:2593
Definition: exprtk.hpp:11992
SType0 s0_
Definition: exprtk.hpp:15122
range_pack< T > range_t
Definition: exprtk.hpp:11421
T process_impl(const operator_type operation, const T arg)
Definition: exprtk.hpp:4750
expression_node_ptr synthesize_uvouv_expression(const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33583
Definition: exprtk.hpp:28569
bool result()
Definition: exprtk.hpp:3416
std::size_t symbols(Sequence< symbol_t, Allocator > &symbols_list)
Definition: exprtk.hpp:19084
details::while_loop_bc_node< T > while_loop_bc_node_t
Definition: exprtk.hpp:18141
type_store< igeneric_function< T >, igeneric_function< T > > generic_function_store
Definition: exprtk.hpp:16609
symbol_table_t::vector_holder_ptr vector_holder_ptr
Definition: exprtk.hpp:18555
std::size_t & max_num_args()
Definition: exprtk.hpp:15780
details::T0oT1oT2oT3_define< T, cref_t, const_t, const_t, cref_t > vococov_t
Definition: exprtk.hpp:18219
results_context_t * results
Definition: exprtk.hpp:17678
static details::operator_type operation()
Definition: exprtk.hpp:12200
Definition: exprtk.hpp:30133
std::string & s2()
Definition: exprtk.hpp:15115
Definition: exprtk.hpp:13443
T acosh_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1284
Definition: exprtk.hpp:19260
SType1 s1_
Definition: exprtk.hpp:14881
static expression_node< T > * allocate(Allocator &allocator, T0 p0, T1 p1, T2 p2, T3 p3)
Definition: exprtk.hpp:14284
Definition: exprtk.hpp:4914
T hypot_impl(const T v0, const T v1, int_type_tag)
Definition: exprtk.hpp:1042
eof< T > e
Definition: exprtk.hpp:37050
static expression_node< T >::node_type type()
Definition: exprtk.hpp:11999
vds_t vds_
Definition: exprtk.hpp:9899
Definition: exprtk.hpp:565
static T process(const arg_list_t &arg)
Definition: exprtk.hpp:26652
data_ptr_t data_
Definition: exprtk.hpp:4123
expression_node< T > * expression_ptr
Definition: exprtk.hpp:7193
bool is_t0ot1ot2ot3_node(const expression_node< T > *node)
Definition: exprtk.hpp:15304
Definition: exprtk.hpp:32478
static T_ execute(ifunction &f, T_(&v)[7])
Definition: exprtk.hpp:11253
SType1 s1_
Definition: exprtk.hpp:14756
unary_vector_node(const operator_type &opr, expression_ptr branch0)
Definition: exprtk.hpp:10829
Definition: exprtk.hpp:3791
bool is_break_node(const expression_node< T > *node)
Definition: exprtk.hpp:5093
Operation operation_t
Definition: exprtk.hpp:15081
Definition: exprtk.hpp:14592
range_pack< T > range_t
Definition: exprtk.hpp:8859
void init_synthesize_map()
Definition: exprtk.hpp:25446
unary_branch_node< T, Operation > & operator=(unary_branch_node< T, Operation > &)
std::size_t function_count() const
Definition: exprtk.hpp:16795
Definition: exprtk.hpp:4419
static void process(const std::string &scalar_format, parameter_list_t parameters)
Definition: exprtk.hpp:36464
Definition: exprtk.hpp:4449
std::size_t size() const
Definition: exprtk.hpp:4100
void enable_unknown_symbol_resolver(unknown_symbol_resolver *usr=reinterpret_cast< unknown_symbol_resolver * >(0))
Definition: exprtk.hpp:20199
~trinary_node()
Definition: exprtk.hpp:5902
static T result(T)
Definition: exprtk.hpp:1564
node_type::T3 T3
Definition: exprtk.hpp:31809
operator_type operation() const
Definition: exprtk.hpp:13781
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:32954
Definition: exprtk.hpp:13571
static const std::size_t pow10_size
Definition: exprtk.hpp:732
Definition: exprtk.hpp:4893
expression_node_ptr parse_conditional_statement_02(expression_node_ptr condition)
Definition: exprtk.hpp:21241
expression_ptr test_
Definition: exprtk.hpp:6030
Definition: exprtk.hpp:31261
~control_block()
Definition: exprtk.hpp:16666
range_t * range_ptr
Definition: exprtk.hpp:8860
expression< T >::symtab_list_t symbol_table_list_t
Definition: exprtk.hpp:18176
node_type::T2 T2
Definition: exprtk.hpp:32258
details::T0oT1oT2oT3_define< T, cref_t, const_t, cref_t, const_t > vocovoc_t
Definition: exprtk.hpp:18217
details::vector_node< T > vector_node_t
Definition: exprtk.hpp:18150
static T process(Type t1, Type t2)
Definition: exprtk.hpp:12093
lexer::token error_token()
Definition: exprtk.hpp:3432
stringvar_node< T > * strvar_node_ptr
Definition: exprtk.hpp:7727
vector_holder_ptr vector_holder_
Definition: exprtk.hpp:7234
node_type::T3 T3
Definition: exprtk.hpp:32035
bool remove_replace_symbol(const std::string &symbol)
Definition: exprtk.hpp:20189
bool is_comment_start(details::char_cptr itr)
Definition: exprtk.hpp:2338
bool & allow_zero_parameters()
Definition: exprtk.hpp:15765
details::operator_type operator_t
Definition: exprtk.hpp:18185
sosos_node(SType0 p0, SType1 p1, SType2 p2)
Definition: exprtk.hpp:15084
range_t range() const
Definition: exprtk.hpp:7613
range_ptr str0_range_ptr_
Definition: exprtk.hpp:15071
Definition: exprtk.hpp:4932
bool & has_side_effects()
Definition: exprtk.hpp:15770
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:37638
igfun_t::generic_type generic_type
Definition: exprtk.hpp:37432
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1)
Definition: exprtk.hpp:30361
Definition: exprtk.hpp:4411
virtual ~vob_base_node()
Definition: exprtk.hpp:13152
Definition: exprtk.hpp:4164
~multi_switch_node()
Definition: exprtk.hpp:6716
vec_data_store< T > vds_t
Definition: exprtk.hpp:6981
T1 t1_
Definition: exprtk.hpp:14214
std::size_t index
Definition: exprtk.hpp:18299
node_type::T2 T2
Definition: exprtk.hpp:32895
Definition: exprtk.hpp:35709
static T process_4(const Sequence &arg_list)
Definition: exprtk.hpp:12280
const bool loop_body_deletable_
Definition: exprtk.hpp:6265
Definition: exprtk.hpp:4457
range_pack< T > range_t
Definition: exprtk.hpp:14973
expression_node_ptr parse_function_call_0(ifunction< T > *function, const std::string &function_name)
Definition: exprtk.hpp:20981
const token_t & current_token() const
Definition: exprtk.hpp:3997
freefunc00(ff00_functor ff)
Definition: exprtk.hpp:16027
Definition: exprtk.hpp:4921
Definition: exprtk.hpp:19305
Definition: exprtk.hpp:13316
expression(const expression< T > &e)
Definition: exprtk.hpp:17693
expression_node< T >::node_type type() const
Definition: exprtk.hpp:5808
std::pair< expression_ptr, bool > branch_t
Definition: exprtk.hpp:15236
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:38076
static void destroy(st_data *&sd)
Definition: exprtk.hpp:16644
node_type::T0 T0
Definition: exprtk.hpp:32368
T cos_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1290
static T evaluate(const Type x, const Type c12, const Type c11, const Type c10, const Type c9, const Type c8, const Type c7, const Type c6, const Type c5, const Type c4, const Type c3, const Type c2, const Type c1, const Type c0)
Definition: exprtk.hpp:35160
details::stringvar_node< T > stringvar_t
Definition: exprtk.hpp:16586
node_type::T0 T0
Definition: exprtk.hpp:32949
expression_node< T >::node_type type() const
Definition: exprtk.hpp:7553
Definition: exprtk.hpp:18545
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:37259
Definition: exprtk.hpp:4922
node_type::T0 T0
Definition: exprtk.hpp:32088
node_type::T1 T1
Definition: exprtk.hpp:31751
bool final_stmt_return() const
Definition: exprtk.hpp:19157
Definition: exprtk.hpp:33451
Definition: exprtk.hpp:19222
Definition: exprtk.hpp:35400
expression_node< T >::node_type type() const
Definition: exprtk.hpp:13292
const bool v_deletable_
Definition: exprtk.hpp:9477
Definition: exprtk.hpp:4900
Definition: exprtk.hpp:12004
node_type::T3 T3
Definition: exprtk.hpp:32259
T value() const
Definition: exprtk.hpp:9613
Definition: exprtk.hpp:11157
Definition: exprtk.hpp:7127
expression_node_ptr return_call(std::vector< expression_node_ptr > &arg_list)
Definition: exprtk.hpp:27363
Definition: exprtk.hpp:4911
void clear(const bool delete_node=true)
Definition: exprtk.hpp:16504
expression_node< T > * expression_ptr
Definition: exprtk.hpp:9599
string_base_node< T > * str_base_ptr
Definition: exprtk.hpp:8582
range_pack< T > range_t
Definition: exprtk.hpp:7574
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1)
Definition: exprtk.hpp:29708
vovov_t::type0 node_type
Definition: exprtk.hpp:29416
Definition: exprtk.hpp:4437
Definition: exprtk.hpp:32364
expression_node< T > * expression_ptr
Definition: exprtk.hpp:14451
void set_ibom(inv_binary_op_map_t &inv_binary_op_map)
Definition: exprtk.hpp:25534
details::T0oT1oT2_define< T, cref_t, const_t, const_t > vococ_t
Definition: exprtk.hpp:18208
vector_node< T > * vec_node_ptr_
Definition: exprtk.hpp:9745
bool valid_symbol(const std::string &symbol) const
Definition: exprtk.hpp:18583
Definition: exprtk.hpp:17571
Definition: exprtk.hpp:4458
Definition: exprtk.hpp:4459
expression_node< T >::node_type type() const
Definition: exprtk.hpp:6156
vector_node< T > * vector_node_ptr
Definition: exprtk.hpp:10180
std::deque< std::string > v_
Definition: exprtk.hpp:35488
Definition: exprtk.hpp:36455
Definition: exprtk.hpp:3490
Definition: exprtk.hpp:29131
Definition: exprtk.hpp:4414
expression_node< typename node_type::value_type > * allocate(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8, const T9 &t9, const T10 &t10) const
Definition: exprtk.hpp:15625
Definition: exprtk.hpp:19291
Definition: exprtk.hpp:5835
Definition: exprtk.hpp:4448
void copy(const varref_t &src_v, var_t &dest_v)
Definition: exprtk.hpp:35631
#define register_synthezier(S)
scoped_bool_or_restorer(bool &bb)
Definition: exprtk.hpp:20827
opr_base< T >::Type Type
Definition: exprtk.hpp:11994
std::vector< expression_ptr > arg_list_
Definition: exprtk.hpp:8979
Definition: exprtk.hpp:4928
Definition: exprtk.hpp:4424
static T process_4(const Sequence &arg_list)
Definition: exprtk.hpp:12543
expression_node_ptr synthesize_csosr_expression(const details::operator_type &opr, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33822
operator_type operation() const
Definition: exprtk.hpp:14517
expression_node_ptr generic_function_call(igeneric_function_t *gf, std::vector< expression_node_ptr > &arg_list, const std::size_t ¶m_seq_index=std::numeric_limits< std::size_t >::max())
Definition: exprtk.hpp:27253
Definition: exprtk.hpp:4451
Definition: exprtk.hpp:16304
static T process_2(const Sequence &arg_list)
Definition: exprtk.hpp:12760
ivararg_function< T > vararg_function_t
Definition: exprtk.hpp:16590
Definition: exprtk.hpp:4453
virtual operator_type operation() const
Definition: exprtk.hpp:13177
static T process(const T &t0, const T &t1, const T &t2, const bfunc_t bf0, const bfunc_t bf1)
Definition: exprtk.hpp:13486
Definition: exprtk.hpp:4395
virtual bool modify(token &t)=0
range_interface< T > range_interface_t
Definition: exprtk.hpp:11419
std::size_t process(generator &g)
Definition: exprtk.hpp:2973
State start
Definition: x.cpp:24
generic_type::scalar_view scalar_t
Definition: exprtk.hpp:37930
void swap(::possumwood::io::json &j1,::possumwood::io::json &j2) noexcept(is_nothrow_move_constructible<::possumwood::io::json >::value andis_nothrow_move_assignable<::possumwood::io::json >::value)
exchanges the values of two JSON objects
Definition: json.h:14378
node_type::T0 T0
Definition: exprtk.hpp:32425
store_type type
Definition: exprtk.hpp:4162
static void execute(T_(&v)[3], const branch_t(&b)[3])
Definition: exprtk.hpp:11129
Definition: exprtk.hpp:4414
expression_node_ptr cardinal_pow_optimisation_impl(const TType &v, const unsigned int &p)
Definition: exprtk.hpp:28036
Definition: exprtk.hpp:1362
virtual std::size_t vector_size() const =0
bool string_to_real(Iterator &itr_external, const Iterator end, T &t, numeric::details::real_type_tag)
Definition: exprtk.hpp:1820
T(* ufunc_t)(Type t0)
Definition: exprtk.hpp:2006
const Type * vec_
Definition: exprtk.hpp:5313
static T_ execute(ifunction &f, T_(&v)[2])
Definition: exprtk.hpp:11288
std::string arith_opr_to_string(details::operator_type opr)
Definition: exprtk.hpp:19760
vovocov_t::sf4_type sf4_type
Definition: exprtk.hpp:33231
value_t & operator[](const std::size_t &i)
Definition: exprtk.hpp:4240
expression_node_ptr parse_string_range_statement(expression_node_ptr &expression)
Definition: exprtk.hpp:22366
expression_node< typename node_type::value_type > * allocate(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7) const
Definition: exprtk.hpp:15584
node_type::T3 T3
Definition: exprtk.hpp:33291
bool is_voc_node(const expression_node< T > *node)
Definition: exprtk.hpp:15280
type_store< T > type_store_t
Definition: exprtk.hpp:11413
opr_base< T >::Type Type
Definition: exprtk.hpp:12186
Definition: exprtk.hpp:755
static expression_node< T >::node_type type()
Definition: exprtk.hpp:12065
details::functor_t< T >::Type Type
Definition: exprtk.hpp:9001
bool is_hex_digit(const std::string::value_type digit)
Definition: exprtk.hpp:295
parser_state state_
Definition: exprtk.hpp:34659
type_t * type_ptr
Definition: exprtk.hpp:16210
expression_node< T >::node_type type() const
Definition: exprtk.hpp:8559
Definition: exprtk.hpp:19255
expression_node< typename ResultNode::value_type > * allocate(OpType &operation, ExprNode(&branch)[2])
Definition: exprtk.hpp:15417
virtual void set_ref(value_ptr *)
Definition: exprtk.hpp:5277
bool open()
Definition: exprtk.hpp:36611
bool * return_invoked
Definition: exprtk.hpp:17680
std::string str() const
Definition: exprtk.hpp:7945
static T_ execute(ifunction &f, T_(&v)[16])
Definition: exprtk.hpp:11190
static void execute(std::string &s, char_cptr data, const std::size_t size)
Definition: exprtk.hpp:8314
char_cptr base() const
Definition: exprtk.hpp:7603
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:37805
std::string paramseq(const std::size_t &index) const
Definition: exprtk.hpp:23211
covov_t::type1 node_type
Definition: exprtk.hpp:29837
stringvar_ptr get_stringvar(const std::string &string_name) const
Definition: exprtk.hpp:18639
std::size_t size() const
Definition: exprtk.hpp:10947
settings_store & disable_arithmetic_operation(settings_arithmetic_opr arithmetic)
Definition: exprtk.hpp:19580
virtual const T & v() const =0
Definition: exprtk.hpp:4434
void disable_type_checking(Parser &p)
Definition: exprtk.hpp:18091
Definition: exprtk.hpp:5285
vds_t & vds()
Definition: exprtk.hpp:10645
details::T0oT1oT2_define< T, cref_t, cref_t, cref_t > vovov_t
Definition: exprtk.hpp:18202
bool bov_optimisable(const details::operator_type &operation, expression_node_ptr(&branch)[2]) const
Definition: exprtk.hpp:25954
RangePack rp1_
Definition: exprtk.hpp:14958
static T process(const ivector_ptr v)
Definition: exprtk.hpp:12936
Definition: exprtk.hpp:3232
Definition: exprtk.hpp:4920
expression_ptr loop_body_
Definition: exprtk.hpp:6210
expression_node< T > * expression_ptr
Definition: exprtk.hpp:15138
igfun_t::generic_type generic_type
Definition: exprtk.hpp:37245
axpby< T > b1_axpby
Definition: exprtk.hpp:38182
expression_node_ptr vector_element(const std::string &symbol, vector_holder_ptr vector_base, expression_node_ptr index)
Definition: exprtk.hpp:27420
bool coboc_optimisable(const details::operator_type &operation, expression_node_ptr(&branch)[2]) const
Definition: exprtk.hpp:25920
Definition: exprtk.hpp:4425
Definition: exprtk.hpp:11019
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33348
symbol_table_t::generic_function_ptr generic_function_ptr
Definition: exprtk.hpp:18557
Definition: exprtk.hpp:4458
void free(expression_node< T > *&e) const
Definition: exprtk.hpp:15685
Definition: exprtk.hpp:4393
bool enable_commutative_check_
Definition: exprtk.hpp:19794
Definition: exprtk.hpp:6105
const bfunc_t f1_
Definition: exprtk.hpp:13843
Definition: exprtk.hpp:33059
expression_node< typename node_type::value_type > * allocate_ttt(T1 t1, T2 t2, T3 t3) const
Definition: exprtk.hpp:15510
lexer::helper::operator_joiner operator_joiner_2_
Definition: exprtk.hpp:34676
static std::string id()
Definition: exprtk.hpp:14003
Definition: exprtk.hpp:4903
parser< T > & parser_
Definition: exprtk.hpp:20772
parser< T > parser_t
Definition: exprtk.hpp:18512
expression_node_ptr synthesize_shortcircuit_expression(const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:27955
generic_type::scalar_view scalar_t
Definition: exprtk.hpp:37835
Definition: exprtk.hpp:12110
static T_ execute(ifunction &f, T_(&v)[19])
Definition: exprtk.hpp:11169
bool is_ivariable_node(const expression_node< T > *node)
Definition: exprtk.hpp:5021
vovovov_t::type3 node_type
Definition: exprtk.hpp:32610
Definition: exprtk.hpp:29217
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &sf3opr, T0 t0, T1 t1, T2 t2)
Definition: exprtk.hpp:29178
static bool compile_left_impl(expression_generator< Type > &expr_gen, const std::string &id, ExternalType t, expression_node_ptr &node, expression_node_ptr &result)
Definition: exprtk.hpp:29392
Definition: exprtk.hpp:4443
details::T0oT1oT2oT3_define< T, cref_t, cref_t, cref_t, cref_t > vovovov_t
Definition: exprtk.hpp:18210
Definition: exprtk.hpp:12296
static void match_sizes(type &vds0, type &vds1)
Definition: exprtk.hpp:4722
node_type::T1 T1
Definition: exprtk.hpp:32201
vovovov_t::type4 node_type
Definition: exprtk.hpp:33117
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33068
Definition: exprtk.hpp:3620
Definition: exprtk.hpp:14347
details::cons_conditional_node< T > cons_conditional_node_t
Definition: exprtk.hpp:18136
assignment_rebasevec_elem_op_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:9983
T value() const
Definition: exprtk.hpp:9800
Definition: exprtk.hpp:4436
Definition: exprtk.hpp:4427
lexer::token error_token_
Definition: exprtk.hpp:3487
std::size_t ref_count
Definition: exprtk.hpp:16699
void init_branches(std::pair< expression_node< T > *, bool >(&branch)[N], expression_node< T > *b0, expression_node< T > *b1=reinterpret_cast< expression_node< T > * >(0), expression_node< T > *b2=reinterpret_cast< expression_node< T > * >(0), expression_node< T > *b3=reinterpret_cast< expression_node< T > * >(0), expression_node< T > *b4=reinterpret_cast< expression_node< T > * >(0), expression_node< T > *b5=reinterpret_cast< expression_node< T > * >(0), expression_node< T > *b6=reinterpret_cast< expression_node< T > * >(0), expression_node< T > *b7=reinterpret_cast< expression_node< T > * >(0), expression_node< T > *b8=reinterpret_cast< expression_node< T > * >(0), expression_node< T > *b9=reinterpret_cast< expression_node< T > * >(0))
Definition: exprtk.hpp:5726
Definition: exprtk.hpp:4454
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:36904
Definition: exprtk.hpp:26628
static T process(const T &, const T &)
Definition: exprtk.hpp:12177
Definition: exprtk.hpp:4919
Definition: exprtk.hpp:4916
expression_node< T > * expression_ptr
Definition: exprtk.hpp:14971
SType1 s1_
Definition: exprtk.hpp:14956
T value() const
Definition: exprtk.hpp:7420
variable_node()
Definition: exprtk.hpp:6783
static T process_4(const Sequence &arg_list)
Definition: exprtk.hpp:12697
Definition: exprtk.hpp:4449
static T evaluate(const Type x, const Type c5, const Type c4, const Type c3, const Type c2, const Type c1, const Type c0)
Definition: exprtk.hpp:35247
details::stringvar_node< T > stringvar_node_t
Definition: exprtk.hpp:16206
token & set_error(const token_type et, const Iterator begin, const Iterator end, const Iterator base_begin=Iterator(0))
Definition: exprtk.hpp:2097
std::vector< expression_ptr > arg_list_
Definition: exprtk.hpp:6660
const range_t & range_ref() const
Definition: exprtk.hpp:7633
details::T0oT1_define< T, cref_t, const_t > voc_t
Definition: exprtk.hpp:18200
bool remove_function(const std::string &function_name)
Definition: exprtk.hpp:17201
Definition: exprtk.hpp:4902
virtual bool join(const token &, const token &, token &)
Definition: exprtk.hpp:3095
Definition: exprtk.hpp:4899
std::deque< var_t > param_stack
Definition: exprtk.hpp:35703
bool is_invalid_assignment_op(const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:25972
expression_node< T > * expression_ptr
Definition: exprtk.hpp:6484
ff00_functor f
Definition: exprtk.hpp:16030
expression_node_ptr synthesize_sros_expression(const details::operator_type &opr, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33747
static std::string id(expression_generator< Type > &, const details::operator_type, const details::operator_type, const details::operator_type)
Definition: exprtk.hpp:33575
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:29098
const T & v1_
Definition: exprtk.hpp:13382
vec_data_store< T > vds_t
Definition: exprtk.hpp:10827
bool is_false_impl(const T v)
Definition: exprtk.hpp:849
const T & v() const
Definition: exprtk.hpp:14430
symtab_list_t get_symbol_table_list() const
Definition: exprtk.hpp:17812
unknown_symbol_resolver * unknown_symbol_resolver_
Definition: exprtk.hpp:34662
range_t * range_ptr
Definition: exprtk.hpp:14974
expression_node< T >::node_type type() const
Definition: exprtk.hpp:7451
Definition: exprtk.hpp:33171
bool delete_ptr
Definition: exprtk.hpp:20738
~bov_node()
Definition: exprtk.hpp:14557
define_sfop3(00,(x+y)/z,"(t+t)/t") define_sfop3(01
node_type::T2 T2
Definition: exprtk.hpp:30386
shift_right()
Definition: exprtk.hpp:37589
details::T0oT1oT2oT3_sf4< T, T0, T1, T2, T3 > sf4_type
Definition: exprtk.hpp:14343
Definition: exprtk.hpp:18108
expression_node< T > * expression_ptr
Definition: exprtk.hpp:10975
Definition: exprtk.hpp:4431
expression_ptr incrementor_
Definition: exprtk.hpp:6347
type_store< typename details::stringvar_node< T >, std::string > stringvar_store
Definition: exprtk.hpp:16605
scope_handler(parser< T > &p)
Definition: exprtk.hpp:18514
expression_node< T >::node_type type() const
Definition: exprtk.hpp:13775
std::string str() const
Definition: exprtk.hpp:7676
bool enable_strength_reduction_
Definition: exprtk.hpp:19795
::erf real_type_tag
Definition: exprtk.hpp:1195
virtual ~ivararg_function()
Definition: exprtk.hpp:15937
bool is_variable(const std::string &variable_name) const
Definition: exprtk.hpp:17334
Definition: exprtk.hpp:4428
std::size_t size() const
Definition: exprtk.hpp:7686
generic_type::string_view string_t
Definition: exprtk.hpp:36461
all_false()
Definition: exprtk.hpp:37204
bool inequality_disabled(const details::operator_type &inequality)
Definition: exprtk.hpp:19532
T value_type
Definition: exprtk.hpp:13696
node_type::T1 T1
Definition: exprtk.hpp:33344
Definition: exprtk.hpp:13447
const_string_range_node(const std::string &v, const range_t &rp)
Definition: exprtk.hpp:7661
vovovoc_t::type0 node_type
Definition: exprtk.hpp:30499
settings_store & disable_assignment_operation(settings_assignment_opr assignment)
Definition: exprtk.hpp:19593
expression_node< T > * expression_ptr
Definition: exprtk.hpp:7726
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:37447
Definition: exprtk.hpp:4403
std::set< std::string, details::ilesscompare > disabled_func_set_t
Definition: exprtk.hpp:18196
bool enable_collect_funcs_
Definition: exprtk.hpp:19797
static std::pair< bool, vector_t * > make(std::vector< T, Allocator > &v, const bool is_const=false)
Definition: exprtk.hpp:16307
Definition: exprtk.hpp:3171
node_type::T2 T2
Definition: exprtk.hpp:33514
strvar_node_ptr str0_node_ptr_
Definition: exprtk.hpp:8569
repeat_until_loop_bc_node(expression_ptr condition, expression_ptr loop_body)
Definition: exprtk.hpp:6424
Definition: exprtk.hpp:11347
scoped_delete(parser< T > &pr, ptr_t &p)
Definition: exprtk.hpp:20715
T3 t3_
Definition: exprtk.hpp:14216
T value() const
Definition: exprtk.hpp:11816
vococov_t::type0 node_type
Definition: exprtk.hpp:31452
Definition: exprtk.hpp:37923
igeneric_function< T > generic_function_t
Definition: exprtk.hpp:16591
scalar_view(type_store_t &ts)
Definition: exprtk.hpp:4275
T value() const
Definition: exprtk.hpp:7022
node_type::T0 T0
Definition: exprtk.hpp:32725
const bool index_deletable_
Definition: exprtk.hpp:7182
T roundn(const T v0, const T v1)
Definition: exprtk.hpp:1447
operator_type operation() const
Definition: exprtk.hpp:14465
Definition: exprtk.hpp:7720
rebasevector_celem_node(const std::size_t index, vector_holder_ptr vec_holder)
Definition: exprtk.hpp:7198
T pow(const T v0, const T v1)
Definition: exprtk.hpp:1426
node_type::T1 T1
Definition: exprtk.hpp:32313
Definition: exprtk.hpp:14221
static T process_5(const Sequence &arg_list)
Definition: exprtk.hpp:12784
node_type::T1 T1
Definition: exprtk.hpp:31027
ifunction< T > F
Definition: exprtk.hpp:18123
uchar_t hex_to_bin(uchar_t h)
Definition: exprtk.hpp:302
virtual const T & v() const =0
bool eof()
Definition: exprtk.hpp:36741
Definition: exprtk.hpp:6764
igfun_t::generic_type generic_type
Definition: exprtk.hpp:38078
rebasevector_elem_node< T > * rbvec_node_ptr_
Definition: exprtk.hpp:9591
static const double log2
Definition: exprtk.hpp:746
Definition: exprtk.hpp:29175
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:36892
vovoc_t::type0 node_type
Definition: exprtk.hpp:29536
expression_node< T > * expression_ptr
Definition: exprtk.hpp:5984
Definition: exprtk.hpp:4401
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:37978
virtual operator_type operation() const
Definition: exprtk.hpp:13137
expression_node< T >::node_type type() const
Definition: exprtk.hpp:7638
Definition: exprtk.hpp:35724
Definition: exprtk.hpp:4909
vec_binop_vecvec_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:10335
ivariable_ptr var0_
Definition: exprtk.hpp:7368
T1 t1() const
Definition: exprtk.hpp:13796
~vec_binop_vecvec_node()
Definition: exprtk.hpp:10397
bool add_package(Package &package)
Definition: exprtk.hpp:17252
static T process(Type t1, Type t2)
Definition: exprtk.hpp:12123
std::vector< T * > varref_t
Definition: exprtk.hpp:35497
operator_type operation() const
Definition: exprtk.hpp:13346
expression_t expression
Definition: exprtk.hpp:35698
std::size_t size() const
Definition: exprtk.hpp:7456
void copy(const var_t &src_v, lvr_vec_t &dest_v)
Definition: exprtk.hpp:35666
std::pair< T *, std::size_t > lvarref_t
Definition: exprtk.hpp:35499
axpbyz()
Definition: exprtk.hpp:37985
static void assign(RefType t1, Type t2)
Definition: exprtk.hpp:12044
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:30251
opr_base< T >::Type Type
Definition: exprtk.hpp:12563
node_type
Definition: exprtk.hpp:4897
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:32824
std::vector< expression_ptr > arg_list_
Definition: exprtk.hpp:9379
covocov_t::type2 node_type
Definition: exprtk.hpp:32423
opr_base< T >::RefType RefType
Definition: exprtk.hpp:11983
T trunc_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1313
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:37756
static bool parse_inf(Iterator &itr, const Iterator end, T &t, bool negative)
Definition: exprtk.hpp:1786
details::vector_holder< T > * vector_holder_ptr
Definition: exprtk.hpp:18177
bov_node(const expression_ptr brnch, const T &var)
Definition: exprtk.hpp:14551
range_pack< T > range_t
Definition: exprtk.hpp:11608
~function_compositor()
Definition: exprtk.hpp:35911
Definition: exprtk.hpp:19276
node_type & operator=(node_type &)
Definition: exprtk.hpp:14294
Definition: exprtk.hpp:4459
SType1 s1_
Definition: exprtk.hpp:15123
Definition: exprtk.hpp:4906
expression_node< T >::node_type type() const
Definition: exprtk.hpp:10635
T value() const
Definition: exprtk.hpp:11744
vector_assignment_node< T > & operator=(const vector_assignment_node< T > &)
expression_node< T > * branch(const std::size_t &) const
Definition: exprtk.hpp:5608
string_base_node< T > * str_base_ptr
Definition: exprtk.hpp:8741
expression_node_ptr parse_generic_function_call(igeneric_function< T > *function, const std::string &function_name)
Definition: exprtk.hpp:23322
expression_node_ptr synthesize_str_xroxr_expression_impl(const details::operator_type &opr, T0 s0, T1 s1, range_t rp0, range_t rp1)
Definition: exprtk.hpp:33707
bool is_shortcircuit_expression(const details::operator_type &operation) const
Definition: exprtk.hpp:26079
vovovoc_t::type2 node_type
Definition: exprtk.hpp:32198
node_type::T1 T1
Definition: exprtk.hpp:31455
retparam_list_t return_param_type_list() const
Definition: exprtk.hpp:19164
sequence_t & sequence_
Definition: exprtk.hpp:5345
Definition: exprtk.hpp:2023
Definition: exprtk.hpp:32833
T value() const
Definition: exprtk.hpp:7773
details::vec_data_store< Type > vds_t
Definition: exprtk.hpp:5389
generic_type::vector_view vector_t
Definition: exprtk.hpp:38032
vds_t vds_
Definition: exprtk.hpp:7184
Definition: exprtk.hpp:4455
vocovoc_t::type0 node_type
Definition: exprtk.hpp:31024
T root_impl(const T v0, const T v1, int_type_tag)
Definition: exprtk.hpp:1006
control_block()
Definition: exprtk.hpp:17599
Definition: exprtk.hpp:4457
const local_data_t & local_data(const std::size_t &index=0) const
Definition: exprtk.hpp:18946
Definition: exprtk.hpp:2023
bool sf4_optimisable(const std::string &sf4id, details::operator_type &operation)
Definition: exprtk.hpp:25683
bool is_string_operation(const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:26061
node_type::T0 T0
Definition: exprtk.hpp:33006
bool allow_zero_parameters_
Definition: exprtk.hpp:15787
Definition: exprtk.hpp:4906
expression_ptr condition_
Definition: exprtk.hpp:6473
node_type::T0 T0
Definition: exprtk.hpp:32837
#define batch_eqineq_logic_case
static T process(const Sequence< Type, Allocator > &arg_list)
Definition: exprtk.hpp:12497
T value() const
Definition: exprtk.hpp:10562
generic_type::vector_view vector_t
Definition: exprtk.hpp:36460
static control_block * create(expression_ptr e)
Definition: exprtk.hpp:17654
static T process(const ivector_ptr v)
Definition: exprtk.hpp:13074
std::pair< lexer::token, lexer::token > error(const std::size_t index)
Definition: exprtk.hpp:3684
static T process(Type t1, Type t2, Type t3)
Definition: exprtk.hpp:12021
Definition: exprtk.hpp:36944
ff02_functor f
Definition: exprtk.hpp:16050
range_data_type< T > range_data_type_t
Definition: exprtk.hpp:5568
generic_type::vector_view vector_t
Definition: exprtk.hpp:37792
T value() const
Definition: exprtk.hpp:14784
str_xrox_node< T, SType0, SType1, RangePack, Operation > & operator=(str_xrox_node< T, SType0, SType1, RangePack, Operation > &)
Definition: exprtk.hpp:37577
bool process(const std::string &str)
Definition: exprtk.hpp:2212
Definition: exprtk.hpp:11980
T0oT1oT2_sf3< T, T0, T1, T2 > node_type
Definition: exprtk.hpp:13953
static expression_node< T >::node_type type()
Definition: exprtk.hpp:12124
void close(Ptr &p)
Definition: exprtk.hpp:36666
Definition: exprtk.hpp:17557
rol()
Definition: exprtk.hpp:37438
details::string_range_node< T > string_range_node_t
Definition: exprtk.hpp:18155
Definition: exprtk.hpp:10971
~unary_vector_node()
Definition: exprtk.hpp:10864
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:32299
functor_t::tfunc_t trinary_functor_t
Definition: exprtk.hpp:18181
void disable_zero_parameters(FunctionType &func)
Definition: exprtk.hpp:15805
Definition: exprtk.hpp:4407
Definition: exprtk.hpp:19274
bool add_function(const std::string &function_name, generic_function_t &function)
Definition: exprtk.hpp:17039
Definition: exprtk.hpp:4924
scoped_vec_delete(parser< T > &pr, std::vector< ptr_t > &vec)
Definition: exprtk.hpp:20785
Definition: exprtk.hpp:4443
opr_base< T >::Type Type
Definition: exprtk.hpp:12052
std::pair< expression_ptr, bool > branch_t
Definition: exprtk.hpp:5785
node_type::T0 T0
Definition: exprtk.hpp:31750
vector_holder< T > * vector_holder_ptr
Definition: exprtk.hpp:10332
generic_function_ptr get_string_function(const std::string &function_name) const
Definition: exprtk.hpp:16872
const bool condition_deletable_
Definition: exprtk.hpp:6350
#define string_opr_switch_statements
Definition: exprtk.hpp:33659
settings_assignment_opr
Definition: exprtk.hpp:19295
virtual std::size_t process(generator &)
Definition: exprtk.hpp:2858
expression_node< T > * expression_ptr
Definition: exprtk.hpp:13280
opr_base< T >::Type Type
Definition: exprtk.hpp:12140
T2 t2_
Definition: exprtk.hpp:14298
Definition: exprtk.hpp:12184
node_type::T1 T1
Definition: exprtk.hpp:33289
bool add_vector(const std::string &vector_name, std::vector< T, Allocator > &v)
Definition: exprtk.hpp:17155
Definition: exprtk.hpp:4398
node_type::T0 T0
Definition: exprtk.hpp:32312
array_vector_impl(const Type *vec, const std::size_t &vec_size)
Definition: exprtk.hpp:5289
details::functor_t< T > functor_t
Definition: exprtk.hpp:13694
void return_cleanup()
Definition: exprtk.hpp:34634
nthelement()
Definition: exprtk.hpp:37703
expression_node< T > * expression_ptr
Definition: exprtk.hpp:6168
Definition: exprtk.hpp:4414
ipowinv_node(const T &v)
Definition: exprtk.hpp:15208
Definition: exprtk.hpp:4925
void load_compile_options(const std::size_t compile_options)
Definition: exprtk.hpp:19729
details::functor_t< T > functor_t
Definition: exprtk.hpp:9002
bool & collect_assignments()
Definition: exprtk.hpp:19147
vector_holder_ptr temp_
Definition: exprtk.hpp:10965
T shl_impl(const T v0, const T v1, real_type_tag)
Definition: exprtk.hpp:1072
vovovoc_t::sf4_type sf4_type
Definition: exprtk.hpp:32667
expression_node_ptr synthesize_uvec_expression(const details::operator_type &operation, expression_node_ptr(&branch)[1])
Definition: exprtk.hpp:26805
operator_type operation() const
Definition: exprtk.hpp:14420
Definition: exprtk.hpp:4907
opr_base< T >::Type Type
Definition: exprtk.hpp:12231
bool initialised_
Definition: exprtk.hpp:10320
symbol_list_t symbol_name_list_
Definition: exprtk.hpp:19215
std::size_t size() const
Definition: exprtk.hpp:8544
bool valid_base_operation(const std::string &symbol)
Definition: exprtk.hpp:20222
vector_holder_t * vector_holder_
Definition: exprtk.hpp:7064
static T process(Type t1, Type t2)
Definition: exprtk.hpp:11984
range_pack< T > range_t
Definition: exprtk.hpp:5587
igfun_t::generic_type generic_type
Definition: exprtk.hpp:37337
vds_t vds_
Definition: exprtk.hpp:7065
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:37543
Definition: exprtk.hpp:37376
Definition: exprtk.hpp:4456
covocov_t::sf4_type sf4_type
Definition: exprtk.hpp:30836
static const double pi_2
Definition: exprtk.hpp:740
node_type::T2 T2
Definition: exprtk.hpp:32540
string_base_node< T > * str_base_ptr
Definition: exprtk.hpp:8449
Definition: exprtk.hpp:7987
bool modify(lexer::token &t)
Definition: exprtk.hpp:3596
Definition: exprtk.hpp:4064
control_block::st_data local_data_t
Definition: exprtk.hpp:17536
const T c_
Definition: exprtk.hpp:14437
details::assignment_vecvec_node< T > assignment_vecvec_node_t
Definition: exprtk.hpp:18169
static bool is_constant(const expression< T > &expr)
Definition: exprtk.hpp:17928
expression_node< T > * expression_ptr
Definition: exprtk.hpp:4939
const std::string value_
Definition: exprtk.hpp:7715
T third_derivative(const expression< T > &e, T &x, const T &h=T(0.0001))
Definition: exprtk.hpp:34929
T value() const
Definition: exprtk.hpp:11529
~unary_node()
Definition: exprtk.hpp:5662
long long int to_int64_impl(const T v, real_type_tag)
Definition: exprtk.hpp:837
node_type::T3 T3
Definition: exprtk.hpp:32671
bool peek_token_is(const std::string &s)
Definition: exprtk.hpp:4050
unknown_type_tag type
Definition: exprtk.hpp:760
virtual ~helper_interface()
Definition: exprtk.hpp:2859
Definition: exprtk.hpp:37634
vector_node< T > vector_node_t
Definition: exprtk.hpp:11416
Definition: exprtk.hpp:4404
bool is_integer_impl(const T &v, real_type_tag)
Definition: exprtk.hpp:1349
T & variable_ref(const std::string &symbol_name)
Definition: exprtk.hpp:16894
T shl(const T v0, const T v1)
Definition: exprtk.hpp:1475
Definition: exprtk.hpp:25435
std::vector< range_data_type_t > range_list_t
Definition: exprtk.hpp:11426
bool is_constant_node(const expression_node< T > *node)
Definition: exprtk.hpp:5081
std::size_t size() const
Definition: exprtk.hpp:8411
Definition: exprtk.hpp:12641
expression_node< typename node_type::value_type > * allocate(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6) const
Definition: exprtk.hpp:15573
Definition: exprtk.hpp:35751
expression_node< typename node_type::value_type > * allocate(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8, const T9 &t9) const
Definition: exprtk.hpp:15610
Definition: exprtk.hpp:4441
static T process_5(const Sequence &arg_list)
Definition: exprtk.hpp:12410
void reset()
Definition: exprtk.hpp:3437
Definition: exprtk.hpp:4449
count()
Definition: exprtk.hpp:37342
Definition: exprtk.hpp:29655
disabled_entity_set_t::iterator des_itr_t
Definition: exprtk.hpp:19227
parser< T > parser_t
Definition: exprtk.hpp:18319
Definition: exprtk.hpp:4456
token_advance_mode
Definition: exprtk.hpp:4002
variable_node_t * variable_node_ptr
Definition: exprtk.hpp:18318
static T process_5(const Sequence &arg_list)
Definition: exprtk.hpp:12551
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:28128
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:29539
~vec_binop_valvec_node()
Definition: exprtk.hpp:10711
type_store< T > type_store_t
Definition: exprtk.hpp:4222
vovovov_t::sf4_type sf4_type
Definition: exprtk.hpp:30383
details::const_string_range_node< T > const_string_range_node_t
Definition: exprtk.hpp:18156
T1 t1_
Definition: exprtk.hpp:14297
vectorize_node(const expression_ptr v)
Definition: exprtk.hpp:9436
std::pair< bool, std::size_t > n0_c
Definition: exprtk.hpp:6944
std::size_t input_param_cnt_
Definition: exprtk.hpp:18505
number_type()
Definition: exprtk.hpp:761
string_base_node< T > * str_base_ptr
Definition: exprtk.hpp:8858
expression_ptr initialiser_
Definition: exprtk.hpp:6575
expression_ptr consequent_
Definition: exprtk.hpp:6031
opr_base< T >::Type Type
Definition: exprtk.hpp:12030
Definition: exprtk.hpp:4440
const bfunc_t f_
Definition: exprtk.hpp:13753
bool symbol_used(const std::string &symbol) const
Definition: exprtk.hpp:36051
expression_node< typename ResultNode::value_type > * allocate(OpType &operation, ExprNode(&branch)[6])
Definition: exprtk.hpp:15441
range_pack< T > range_t
Definition: exprtk.hpp:7659
std::string scalar_format_
Definition: exprtk.hpp:36552
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:30014
void free_node(NodeAllocator &node_allocator, expression_node< T > *&node, const bool force_delete=false)
Definition: exprtk.hpp:5220
T nand_opr(const T v0, const T v1)
Definition: exprtk.hpp:1489
expression_node< T > * expression_ptr
Definition: exprtk.hpp:8447
vector_node_ptr vec()
Definition: exprtk.hpp:10937
vovovov_t::type1 node_type
Definition: exprtk.hpp:31640
T & operator[](const std::size_t index)
Definition: exprtk.hpp:4110
const bool loop_body_deletable_
Definition: exprtk.hpp:6476
uchar_t * uchar_ptr
Definition: exprtk.hpp:88
Definition: exprtk.hpp:37875
void set_c(const T new_c)
Definition: exprtk.hpp:14688
irange_t * irange_ptr
Definition: exprtk.hpp:8745
irange_ptr str_range_ptr_
Definition: exprtk.hpp:8978
T xnor_impl(const T v0, const T v1, int_type_tag)
Definition: exprtk.hpp:1172
node_type::T2 T2
Definition: exprtk.hpp:31696
expression_node< T > * expression_ptr
Definition: exprtk.hpp:8581
Definition: exprtk.hpp:2028
Definition: exprtk.hpp:16063
Definition: exprtk.hpp:15231
opr_base< T >::RefType RefType
Definition: exprtk.hpp:12031
const qfunc_t f_
Definition: exprtk.hpp:14217
type_store< vector_holder_t, vector_holder_t > vector_store
Definition: exprtk.hpp:16611
Definition: exprtk.hpp:4441
void free()
Definition: exprtk.hpp:6847
std::size_t size() const
Definition: exprtk.hpp:8698
std::string as_string() const
Definition: exprtk.hpp:407
token_t operator[](const std::size_t &index) const
Definition: exprtk.hpp:2286
vector_node< T > * vec0_node_ptr_
Definition: exprtk.hpp:7473
bool sequence_match(const std::string &pattern, const std::string &str, std::size_t &diff_index, char_t &diff_value)
Definition: exprtk.hpp:654
expression_node< T > * expression_ptr
Definition: exprtk.hpp:9944
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:37928
bool result()
Definition: exprtk.hpp:3501
vector_node(vector_holder_t *vh)
Definition: exprtk.hpp:7010
parser_t::settings_store settings_t
Definition: exprtk.hpp:35398
T0oT1oT2_sf3(node_type &)
Definition: exprtk.hpp:14018
std::size_t get_list(Sequence< std::string, Allocator > &vlist) const
Definition: exprtk.hpp:16560
expression_node_ptr parse_multi_switch_statement()
Definition: exprtk.hpp:22170
expression_node< T >::node_type type() const
Definition: exprtk.hpp:14933
Definition: exprtk.hpp:4931
expression_node< T > * expression_ptr
Definition: exprtk.hpp:10999
std::size_t size() const
Definition: exprtk.hpp:7042
Definition: exprtk.hpp:5251
igeneric_function< T >::generic_type generic_type
Definition: exprtk.hpp:36457
T * vector_base_
Definition: exprtk.hpp:7122
covocov_t::sf4_type sf4_type
Definition: exprtk.hpp:31918
static T return_value(expression_t &e)
Definition: exprtk.hpp:35821
variable_node_t * variable_node_ptr_t
Definition: exprtk.hpp:11417
Definition: exprtk.hpp:4401
static const double _180_pi
Definition: exprtk.hpp:745
Definition: exprtk.hpp:19283
static details::operator_type operation()
Definition: exprtk.hpp:12152
Definition: exprtk.hpp:20386
bool is_function(const std::string &function_name) const
Definition: exprtk.hpp:18871
char_cptr base() const
Definition: exprtk.hpp:7523
Definition: exprtk.hpp:4542
Definition: exprtk.hpp:8999
assignment_rebasevec_celem_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:9601
Definition: exprtk.hpp:4928
Definition: exprtk.hpp:4413
bfunc_t f0() const
Definition: exprtk.hpp:13896
Definition: exprtk.hpp:4414
bool joiner_enabled() const
Definition: exprtk.hpp:19427
std::size_t variable_count() const
Definition: exprtk.hpp:16777
static void print(const std::string &scalar_format, const vector_t &v)
Definition: exprtk.hpp:36491
function & expression(const std::string &e)
Definition: exprtk.hpp:35474
Definition: exprtk.hpp:4914
void skip_whitespace()
Definition: exprtk.hpp:2355
generic_type::string_view string_t
Definition: exprtk.hpp:36820
variable_ptr get_variable(const std::string &variable_name) const
Definition: exprtk.hpp:16811
Definition: exprtk.hpp:15201
static expression_node< T >::node_type type()
Definition: exprtk.hpp:12034
vector_node< T > * vec0_node_ptr_
Definition: exprtk.hpp:10318
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:32842
static void destroy(control_block *&cntrl_blck, SymTab *sym_tab)
Definition: exprtk.hpp:16680
vococov_t::type2 node_type
Definition: exprtk.hpp:32593
range_interface< T > irange_t
Definition: exprtk.hpp:14975
std::size_t size() const
Definition: exprtk.hpp:8952
assignment_rebasevec_elem_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:9563
Definition: exprtk.hpp:4396
Definition: exprtk.hpp:6418
T pow_impl(const T v0, const T v1, real_type_tag)
Definition: exprtk.hpp:941
vds_t vds_
Definition: exprtk.hpp:9746
std::string str() const
Definition: exprtk.hpp:7598
void enable_zero_parameters(FunctionType &func)
Definition: exprtk.hpp:15794
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:37927
ff13_functor f
Definition: exprtk.hpp:16169
any_true()
Definition: exprtk.hpp:37250
T value() const
Definition: exprtk.hpp:7154
parser< T > parser_t
Definition: exprtk.hpp:23133
T const_e_impl(real_type_tag)
Definition: exprtk.hpp:1316
Type type_t
Definition: exprtk.hpp:16209
cov_node< T, Operation > & operator=(const cov_node< T, Operation > &)
string_base_node< T > * str_base_ptr
Definition: exprtk.hpp:8263
const T & v0_
Definition: exprtk.hpp:13381
settings_store & enable_all_inequality_ops()
Definition: exprtk.hpp:19353
const T & ref() const
Definition: exprtk.hpp:6806
axpy< T > b1_axpy
Definition: exprtk.hpp:38181
static T process_5(const Sequence &arg_list)
Definition: exprtk.hpp:12628
const bool incrementor_deletable_
Definition: exprtk.hpp:6581
T value() const
Definition: exprtk.hpp:5598
T & RefType
Definition: exprtk.hpp:2002
bfunc_t f2() const
Definition: exprtk.hpp:13906
static T process(Type t1, Type t2, Type t3)
Definition: exprtk.hpp:11985
expression_node< typename node_type::value_type > * allocate_type(T1 t1, T2 t2, T3 t3) const
Definition: exprtk.hpp:15636
~return_envelope_node()
Definition: exprtk.hpp:11859
covovov_t::sf4_type sf4_type
Definition: exprtk.hpp:31861
token()
Definition: exprtk.hpp:2033
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33237
operator_type operation() const
Definition: exprtk.hpp:15100
void begin()
Definition: exprtk.hpp:2242
details::vector_holder< T > vector_holder_t
Definition: exprtk.hpp:18236
Definition: exprtk.hpp:4270
void set_sf3m(sf3_map_t &sf3_map)
Definition: exprtk.hpp:25539
bool is_function(const std::string &function_name) const
Definition: exprtk.hpp:17367
std::string construct_subexpr(lexer::token &begin_token, lexer::token &end_token)
Definition: exprtk.hpp:20372
void load_operations_map(std::multimap< std::string, details::base_operation_t, details::ilesscompare > &m)
Definition: exprtk.hpp:15692
std::size_t local_var_stack_size
Definition: exprtk.hpp:35701
operator_type operation() const
Definition: exprtk.hpp:14938
opr_base< T >::Type Type
Definition: exprtk.hpp:12102
Definition: exprtk.hpp:16043
void set_ref(value_ptr *ref)
Definition: exprtk.hpp:5423
T pow_impl(const T v0, const T v1, int_type_tag)
Definition: exprtk.hpp:947
void update(const T &v0)
Definition: exprtk.hpp:35515
ifunction(const std::size_t &pc)
Definition: exprtk.hpp:15842
std::size_t size() const
Definition: exprtk.hpp:11663
bool branch_deletable_
Definition: exprtk.hpp:5701
node_type::T3 T3
Definition: exprtk.hpp:32315
value_t * end()
Definition: exprtk.hpp:4258
Definition: exprtk.hpp:2018
std::pair< std::string, symbol_type > symbol_t
Definition: exprtk.hpp:19070
Definition: exprtk.hpp:4437
bool parsing_return_stmt
Definition: exprtk.hpp:18988
Definition: exprtk.hpp:37828
settings_store & disable_all_control_structures()
Definition: exprtk.hpp:19374
type_store< igeneric_function< T >, igeneric_function< T > > string_function_store
Definition: exprtk.hpp:16610
Definition: exprtk.hpp:30833
type_view(const type_store_t &ts)
Definition: exprtk.hpp:4230
std::string synthesis_error_
Definition: exprtk.hpp:34670
T axnb(T a, T x, T b)
Definition: exprtk.hpp:8992
igeneric_function_t * igeneric_function_ptr
Definition: exprtk.hpp:11806
static T process_2(const Sequence &arg_list)
Definition: exprtk.hpp:12460
variable_node_ptr var0_
Definition: exprtk.hpp:7337
Definition: exprtk.hpp:4908
static details::operator_type operation()
Definition: exprtk.hpp:12066
expression_node< T >::node_type type() const
Definition: exprtk.hpp:5487
bool is_constant_string(const std::string &symbol_name) const
Definition: exprtk.hpp:18783
Definition: exprtk.hpp:18230
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:37167
symtab_list_t symbol_table_list_
Definition: exprtk.hpp:17916
string_literal_node< T > & operator=(const string_literal_node< T > &)
Definition: exprtk.hpp:14715
expression_node< T >::node_type type() const
Definition: exprtk.hpp:7970
Definition: exprtk.hpp:12120
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:29074
const T & v1_
Definition: exprtk.hpp:14388
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:38123
node_type::T0 T0
Definition: exprtk.hpp:33288
Definition: exprtk.hpp:4928
expression_node< T >::node_type type() const
Definition: exprtk.hpp:6023
std::deque< bool > brkcnt_list_
Definition: exprtk.hpp:34658
vocovov_t::sf4_type sf4_type
Definition: exprtk.hpp:32311
void register_local_var(expression_ptr expr)
Definition: exprtk.hpp:17833
T value() const
Definition: exprtk.hpp:15018
std::string str() const
Definition: exprtk.hpp:8688
bool is_return_node(const expression_node< T > *node)
Definition: exprtk.hpp:5117
static T process(const T &t0, const T &t1, const T &t2, const T &t3, const bfunc_t bf0, const bfunc_t bf1, const bfunc_t bf2)
Definition: exprtk.hpp:13594
Definition: exprtk.hpp:4454
Definition: exprtk.hpp:4926
void release()
Definition: exprtk.hpp:13429
bool enable_sequence_check_
Definition: exprtk.hpp:19793
T1 t1() const
Definition: exprtk.hpp:14079
conditional_string_node(expression_ptr test, expression_ptr consequent, expression_ptr alternative)
Definition: exprtk.hpp:8588
expression_node_ptr parse_define_var_statement()
Definition: exprtk.hpp:24160
T value() const
Definition: exprtk.hpp:8377
T sqrt_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1301
value_t
the JSON type enumeration
Definition: json.h:407
std::size_t ref_count
Definition: exprtk.hpp:18301
igfun_t::generic_type generic_type
Definition: exprtk.hpp:37881
unsigned int batch_size
Definition: exprtk.hpp:4519
exprtk::igeneric_function< T > igfun_t
Definition: exprtk.hpp:37005
unary_op_map_t * unary_op_map_
Definition: exprtk.hpp:34363
bool type_check_enabled
Definition: exprtk.hpp:18992
static details::operator_type operation()
Definition: exprtk.hpp:12056
static T process(const std::string &t0, const std::string &t1, const std::string &t2)
Definition: exprtk.hpp:12208
range_pack< T > range_t
Definition: exprtk.hpp:7729
vec_data_store< T > vds_t
Definition: exprtk.hpp:10333
Definition: exprtk.hpp:13461
int to_int32_impl(const T v, real_type_tag)
Definition: exprtk.hpp:831
while_loop_bc_node(expression_ptr condition, expression_ptr loop_body)
Definition: exprtk.hpp:6363
static void assign(RefType t1, Type t2)
Definition: exprtk.hpp:12022
expression_node_ptr synthesize_string_expression(const details::operator_type &opr, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33985
irange_ptr str0_range_ptr_
Definition: exprtk.hpp:7980
const T & v3_
Definition: exprtk.hpp:9320
node_type::T3 T3
Definition: exprtk.hpp:32541
expression_node< T > * expression_ptr
Definition: exprtk.hpp:14401
std::string str() const
Definition: exprtk.hpp:8808
details::expression_node< T > expression_node_t
Definition: exprtk.hpp:18129
Definition: exprtk.hpp:4449
data_pack()
Definition: exprtk.hpp:17579
const T1
Definition: exprtk.hpp:13628
virtual T operator()(parameter_list_t)
Definition: exprtk.hpp:11793
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:32673
T0 t0() const
Definition: exprtk.hpp:13876
expression_node_ptr parse_swap_statement()
Definition: exprtk.hpp:24429
boc_node(const expression_ptr brnch, const T const_var)
Definition: exprtk.hpp:14662
details::assignment_rebasevec_celem_node< T > assignment_rebasevec_celem_node_t
Definition: exprtk.hpp:18167
Definition: exprtk.hpp:4927
Definition: exprtk.hpp:4934
~rebasevector_elem_node()
Definition: exprtk.hpp:7146
value_type * value_ptr
Definition: exprtk.hpp:5248
range_t * range_ptr
Definition: exprtk.hpp:8743
static expression_node_ptr process(expression_generator< Type > &expr_gen, const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33404
std::size_t get_variable_list(Sequence< std::string, Allocator > &vlist) const
Definition: exprtk.hpp:17269
node_type::T0 T0
Definition: exprtk.hpp:32668
Definition: exprtk.hpp:4453
void post()
Definition: exprtk.hpp:35613
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:37527
void clear()
Definition: exprtk.hpp:6838
string_base_node< T > * str_base_ptr
Definition: exprtk.hpp:8076
const char_t & front(const std::string &s)
Definition: exprtk.hpp:251
Definition: exprtk.hpp:4398
std::vector< expression_ptr > arg_list_
Definition: exprtk.hpp:6759
expression_node< T > * expression_ptr
Definition: exprtk.hpp:9293
const type_store & operator[](const std::size_t &index) const
Definition: exprtk.hpp:4187
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:37431
generic_type::vector_view vector_t
Definition: exprtk.hpp:37338
static T process_3(const Sequence &arg_list)
Definition: exprtk.hpp:12767
T root_impl(const T v0, const T v1, real_type_tag)
Definition: exprtk.hpp:992
static T evaluate(const Type x, const Type c8, const Type c7, const Type c6, const Type c5, const Type c4, const Type c3, const Type c2, const Type c1, const Type c0)
Definition: exprtk.hpp:35211
expression_node< T >::node_type type() const
Definition: exprtk.hpp:9873
T hypot(const T v0, const T v1)
Definition: exprtk.hpp:1454
std::string str() const
Definition: exprtk.hpp:8401
Definition: exprtk.hpp:16160
T xnor_opr(const T v0, const T v1)
Definition: exprtk.hpp:1517
static details::operator_type operation()
Definition: exprtk.hpp:12161
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:37880
char_cptr base() const
Definition: exprtk.hpp:7681
static expression_node< T > * allocate(Allocator &allocator, T0 p0, T1 p1, T2 p2, T3 p3, bfunc_t p4, bfunc_t p5, bfunc_t p6)
Definition: exprtk.hpp:13922
static T_ execute(ifunction &f, T_(&v)[15])
Definition: exprtk.hpp:11197
vector_holder< T > * vector_holder_ptr
Definition: exprtk.hpp:10826
details::for_loop_node< T > for_loop_node_t
Definition: exprtk.hpp:18139
bool register_scanner(lexer::token_scanner *scanner)
Definition: exprtk.hpp:3793
std::vector< symbol_table_t * > auxiliary_symtab_list_
Definition: exprtk.hpp:36130
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:37336
bool add_vector(const std::string &vector_name, T(&v)[N])
Definition: exprtk.hpp:17128
#define exprtk_disable_fallthrough_end
Definition: exprtk.hpp:81
axpyz< T > b1_axpyz
Definition: exprtk.hpp:38183
std::vector< data_ptr_t * > data_ref_
Definition: exprtk.hpp:4124
expression_node< T >::node_type type() const
Definition: exprtk.hpp:15150
static std::string id()
Definition: exprtk.hpp:13561
static bool is_null(const expression< T > &expr)
Definition: exprtk.hpp:17953
Definition: exprtk.hpp:16599
Definition: exprtk.hpp:19261
std::size_t size() const
Definition: exprtk.hpp:5623
bool is_valid(const expression< T > &expr)
Definition: exprtk.hpp:17960
std::deque< ptr_t > & deq_
Definition: exprtk.hpp:20773
range_t & range_ref()
Definition: exprtk.hpp:8957
vector_node_ptr vec() const
Definition: exprtk.hpp:9863
expression_node< T >::node_type type() const
Definition: exprtk.hpp:8713
virtual const T c() const =0
expression_node< T >::node_type type() const
Definition: exprtk.hpp:9723
Definition: exprtk.hpp:6973
Definition: exprtk.hpp:18104
bool is_integer_impl(const T &, int_type_tag)
Definition: exprtk.hpp:1355
T nequal(const T v0, const T v1)
Definition: exprtk.hpp:1412
func_4param()
Definition: exprtk.hpp:35783
Definition: exprtk.hpp:4424
Definition: exprtk.hpp:8312
expression_node< typename node_type::value_type > * allocate_rc(T1 &t1, const T2 &t2) const
Definition: exprtk.hpp:15489
T atan2(const T v0, const T v1)
Definition: exprtk.hpp:1461
expression_ptr alternative_
Definition: exprtk.hpp:6032
node_type::T3 T3
Definition: exprtk.hpp:32784
details::repeat_until_loop_bc_node< T > repeat_until_loop_bc_node_t
Definition: exprtk.hpp:18142
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:32469
std::string get_stringvar_name(const expression_ptr &ptr) const
Definition: exprtk.hpp:17402
const tfunc_t f_
Definition: exprtk.hpp:14024
range_pack< T > range_t
Definition: exprtk.hpp:8077
expression_node< T >::node_type type() const
Definition: exprtk.hpp:5677
bool cov_optimisable(const details::operator_type &operation, expression_node_ptr(&branch)[2]) const
Definition: exprtk.hpp:25859
igfun_t::generic_type generic_type
Definition: exprtk.hpp:37480
details::T0oT1oT2< T, T0, T1, T2, typename T0oT1oT2process< T >::mode1 > type1
Definition: exprtk.hpp:14330
token_t store_current_token_
Definition: exprtk.hpp:4059
details::assignment_string_node< T > assignment_string_node_t
Definition: exprtk.hpp:18159
std::string to_str(error_mode mode)
Definition: exprtk.hpp:18022
Definition: exprtk.hpp:37147
Definition: exprtk.hpp:29595
virtual T value(expression_t &e)
Definition: exprtk.hpp:35693
expression_node< T >::node_type type() const
Definition: exprtk.hpp:7169
vector_node_ptr vec() const
Definition: exprtk.hpp:9713
Definition: exprtk.hpp:4909
variable_ptr get_variable(const T &var_ref) const
Definition: exprtk.hpp:18620
bool symbol_exists(const std::string &symbol) const
Definition: exprtk.hpp:18802
const bool initialiser_deletable_
Definition: exprtk.hpp:6349
dot< T > dt
Definition: exprtk.hpp:38186
static const expression_node< T >::node_type result
Definition: exprtk.hpp:13661
vector_interface< T > * ivec_ptr_
Definition: exprtk.hpp:9475
std::size_t error_count() const
Definition: exprtk.hpp:3529
vector_node_ptr vec0_node_ptr_
Definition: exprtk.hpp:10657
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:37381
bool is_invalid_inequality_operation(const details::operator_type operation)
Definition: exprtk.hpp:20273
bool is_function(const expression_node< T > *node)
Definition: exprtk.hpp:5111
symbol_table_t::vararg_function_ptr vararg_function_ptr
Definition: exprtk.hpp:18556
bool initialised_
Definition: exprtk.hpp:8065
Definition: exprtk.hpp:4395
T1 t1_
Definition: exprtk.hpp:13752
func_3param()
Definition: exprtk.hpp:35769
static T process_2(const Sequence &arg_list)
Definition: exprtk.hpp:12598
generator_t lexer_
Definition: exprtk.hpp:4057
bool add_stringvar(const std::string &stringvar_name, std::string &s, const bool is_constant=false)
Definition: exprtk.hpp:17002
Definition: exprtk.hpp:37102
details::unary_node< T > unary_node_t
Definition: exprtk.hpp:18131
T value() const
Definition: exprtk.hpp:6015
void disable_has_side_effects(FunctionType &func)
Definition: exprtk.hpp:15817
T notl_impl(const T v, real_type_tag)
Definition: exprtk.hpp:1311
T value() const
Definition: exprtk.hpp:11700
Definition: exprtk.hpp:15754
Definition: exprtk.hpp:4398
node_type::T2 T2
Definition: exprtk.hpp:32314
expression_node< T >::node_type type() const
Definition: exprtk.hpp:11336
usr_symbol_type
Definition: exprtk.hpp:19001
assignment_string_node(const operator_type &opr, expression_ptr branch0, expression_ptr branch1)
Definition: exprtk.hpp:8339
getline()
Definition: exprtk.hpp:37013
const vds_t & vds() const
Definition: exprtk.hpp:10805
node_type::T1 T1
Definition: exprtk.hpp:31977
bool vardef_disabled() const
Definition: exprtk.hpp:19435
write()
Definition: exprtk.hpp:36900
generic_type::parameter_list parameter_list_t
Definition: exprtk.hpp:15960
expression_node_ptr synthesize_csros_expression(const details::operator_type &opr, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:33911
bool zero_return_disabled() const
Definition: exprtk.hpp:19437
expression_node< typename node_type::value_type > * allocate(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8) const
Definition: exprtk.hpp:15597
~conditional_node()
Definition: exprtk.hpp:5997
Definition: exprtk.hpp:16137
vococov_t::type4 node_type
Definition: exprtk.hpp:33567
igfun_t::parameter_list_t parameter_list_t
Definition: exprtk.hpp:37006
vovovoc_t::type4 node_type
Definition: exprtk.hpp:33173
igfun_t::generic_type generic_type
Definition: exprtk.hpp:37106
Definition: exprtk.hpp:13210
details::conditional_node< T > conditional_node_t
Definition: exprtk.hpp:18135
expression< T > expression_t
Definition: exprtk.hpp:18174
vec_data_store< T > vds_t
Definition: exprtk.hpp:10517
Definition: exprtk.hpp:4438
Definition: exprtk.hpp:26674
retparam_list_t retparam_list_
Definition: exprtk.hpp:19217
expression_ptr loop_body_
Definition: exprtk.hpp:6263
Definition: exprtk.hpp:5705
covovov_t::type1 node_type
Definition: exprtk.hpp:31860
Definition: exprtk.hpp:20781
~vararg_node()
Definition: exprtk.hpp:9353
expression_node_ptr cardinal_pow_optimisation(const T &v, const T &c)
Definition: exprtk.hpp:28064
T0 t0_
Definition: exprtk.hpp:13936
igfun_t::generic_type generic_type
Definition: exprtk.hpp:37739
Definition: exprtk.hpp:4454
sumk()
Definition: exprtk.hpp:37796
range_t * range_ptr
Definition: exprtk.hpp:8584
expression_ptr branch_
Definition: exprtk.hpp:7839
Definition: exprtk.hpp:4901
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1)
Definition: exprtk.hpp:30240
static T result(T v)
Definition: exprtk.hpp:1562
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:30656
std::size_t const_size() const
Definition: exprtk.hpp:6932
vec_data_store< T > vds_t
Definition: exprtk.hpp:7008
vocovoc_t::sf4_type sf4_type
Definition: exprtk.hpp:32948
bool is_invalid_string_op(const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:26020
expression_node< T >::node_type type() const
Definition: exprtk.hpp:10790
bool initialised_
Definition: exprtk.hpp:7476
Definition: exprtk.hpp:4420
std::size_t ref_count
Definition: exprtk.hpp:4613
Definition: exprtk.hpp:4432
bool is_string_node(const expression_node< T > *node)
Definition: exprtk.hpp:15316
vovovoc_t::sf4_type sf4_type
Definition: exprtk.hpp:30500
std::string type_id() const
Definition: exprtk.hpp:13816
#define token_inserter_empty_body
Definition: exprtk.hpp:3047
const bool branch_deletable_
Definition: exprtk.hpp:8308
T operator()(const std::size_t &ps_index, parameter_list_t parameters)
Definition: exprtk.hpp:37305
const value_ptr const_value_ptr
Definition: exprtk.hpp:5249
Definition: exprtk.hpp:2019
expression_node_ptr synthesize_veceqineqlogic_operation_expression(const details::operator_type &operation, expression_node_ptr(&branch)[2])
Definition: exprtk.hpp:27763
const type_store_t & operator[](const std::size_t &index) const
Definition: exprtk.hpp:4359
Definition: exprtk.hpp:29895
std::string str() const
Definition: exprtk.hpp:7518
vocovov_t::sf4_type sf4_type
Definition: exprtk.hpp:30668
bool is_boc_node(const expression_node< T > *node)
Definition: exprtk.hpp:15292
Definition: exprtk.hpp:30380
T value_type
Definition: exprtk.hpp:14138
static std::string id(expression_generator< Type > &expr_gen, const details::operator_type o0, const details::operator_type o1, const details::operator_type o2)
Definition: exprtk.hpp:31441
disabled_entity_set_t disabled_assignment_set_
Definition: exprtk.hpp:19807
const T c() const
Definition: exprtk.hpp:14425
Definition: exprtk.hpp:3553
build_string & operator<<(const std::string &s)
Definition: exprtk.hpp:390
Definition: exprtk.hpp:6039
std::vector< symbol_table< T > > symtab_list_t
Definition: exprtk.hpp:17563
const T & v1_
Definition: exprtk.hpp:9318
Definition: exprtk.hpp:4425
static T process_3(const Sequence &arg_list)
Definition: exprtk.hpp:12340
freefunc07(ff07_functor ff)
Definition: exprtk.hpp:16097
expression_node< T >::node_type type() const
Definition: exprtk.hpp:7296
Definition: exprtk.hpp:13509
T value() const
Definition: exprtk.hpp:8239
opr_base< T >::Type Type
Definition: exprtk.hpp:12041
bool cardinal_pow_optimisable(const details::operator_type &operation, const T &c)
Definition: exprtk.hpp:28085
expression_node< T > * expression_ptr
Definition: exprtk.hpp:9981
Definition: exprtk.hpp:16115
const T c() const
Definition: exprtk.hpp:14470
functor_t::bfunc_t bfunc_t
Definition: exprtk.hpp:13507
T atan2_impl(const T, const T, int_type_tag)
Definition: exprtk.hpp:1054
static bool compile_right_impl(expression_generator< Type > &expr_gen, const std::string &id, ExternalType t, expression_node_ptr &node, expression_node_ptr &result)
Definition: exprtk.hpp:29370
std::string ret_string_
Definition: exprtk.hpp:11681
bool is_left_bracket(const char_t c)
Definition: exprtk.hpp:132
T & ref()
Definition: exprtk.hpp:6801
void clear()
Definition: exprtk.hpp:3589
close< T > c
Definition: exprtk.hpp:37046
disabled_entity_set_t disabled_func_set_
Definition: exprtk.hpp:19803
std::string name
Definition: config.cpp:65
error_mode
Definition: exprtk.hpp:17967